@interactive-inc/claude-funnel 0.10.0 → 0.10.1

package/lib/engine/claude/claude.ts

@@ -1,205 +0,0 @@
-import { join } from "node:path"
-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
-  cwd?: string
-  subAgent?: string
-  userArgs?: string[]
-  profileName?: string
-  /** Forward `--brief` to claude on launch (enables the SendUserMessage tool). */
-  brief?: boolean
-}
-
-type Deps = {
-  channels: FunnelChannels
-  mcp: FunnelMcp
-  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 mcp: FunnelMcp
-  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.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) ?? this.channels.getById(options.channel)
-
-    if (!channel) {
-      throw new Error(`channel "${options.channel}" not found`)
-    }
-
-    if (options.profileName && this.isRunning(options.profileName)) {
-      throw new Error(`profile "${options.profileName}" is already running`)
-    }
-
-    const cwd = options.cwd ?? globalThis.process.cwd()
-
-    if (!this.mcp.findInstalledName(cwd)) {
-      this.mcp.install(cwd)
-
-      this.logger.info(`added funnel MCP to .mcp.json`, { cwd })
-    }
-
-    if (!this.gateway.isRunning()) {
-      this.logger.info(`starting gateway automatically`)
-      await this.gateway.start()
-    }
-
-    if (options.profileName) {
-      this.writePidFile(options.profileName)
-      this.installCleanup(options.profileName)
-    }
-
-    const claudeArgs = this.buildArgs(options, cwd)
-    const env = this.buildEnv(channel.id)
-
-    this.logger.info(`claude launch`, {
-      channel: options.channel,
-      channelId: channel.id,
-      subAgent: options.subAgent,
-      cwd,
-    })
-
-    try {
-      return await this.process.attach(["claude", ...claudeArgs], { cwd, env })
-    } finally {
-      if (options.profileName) this.removePidFile(options.profileName)
-    }
-  }
-
-  isRunning(profileName: string): boolean {
-    const pid = this.readPid(profileName)
-
-    if (!pid) return false
-
-    return this.isProcessAlive(pid)
-  }
-
-  private pidPath(profileName: string): string {
-    return join(this.pidDir, `${profileName}.pid`)
-  }
-
-  private readPid(profileName: string): number | null {
-    const path = this.pidPath(profileName)
-
-    if (!this.fs.existsSync(path)) return null
-
-    try {
-      const content = this.fs.readFileSync(path).trim()
-      const pid = Number(content)
-
-      if (!pid || pid <= 0) return null
-
-      return pid
-    } catch {
-      return null
-    }
-  }
-
-  private writePidFile(profileName: string): void {
-    this.fs.mkdirSync(this.pidDir, { recursive: true })
-    this.fs.writeFileSync(this.pidPath(profileName), String(globalThis.process.pid))
-  }
-
-  private removePidFile(profileName: string): void {
-    const path = this.pidPath(profileName)
-
-    if (this.fs.existsSync(path)) this.fs.unlink(path)
-  }
-
-  private installCleanup(profileName: string): void {
-    // 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 {
-    const result = this.process.runSync(["ps", "-p", String(pid), "-o", "state="])
-
-    if (result.exitCode !== 0) return false
-
-    const state = result.stdout.trim()
-
-    if (!state) return false
-
-    return !state.startsWith("Z")
-  }
-
-  private buildArgs(options: LaunchOptions, cwd: string): string[] {
-    const result = [...(options.userArgs ?? [])]
-
-    const mcpName = this.mcp.findInstalledName(cwd)
-
-    if (
-      mcpName &&
-      !result.includes("--dangerously-load-development-channels") &&
-      !result.includes("--channels")
-    ) {
-      result.push("--dangerously-load-development-channels", `server:${mcpName}`)
-    }
-
-    if (!result.includes("--agent") && options.subAgent) {
-      result.push("--agent", options.subAgent)
-    }
-
-    if (options.brief && !result.includes("--brief")) {
-      result.push("--brief")
-    }
-
-    return result
-  }
-
-  private buildEnv(channelId: string): Record<string, string> {
-    const env: Record<string, string> = {}
-
-    for (const [key, value] of Object.entries(globalThis.process.env)) {
-      if (typeof value === "string") env[key] = value
-    }
-
-    env.FUNNEL_CHANNEL_ID = channelId
-
-    return env
-  }
-}

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

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

package/lib/engine/fs/file-system.ts

@@ -1,23 +0,0 @@
-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
-  abstract readdirSync(path: string): string[]
-  abstract statSync(path: string): FileStat
-}

package/lib/engine/fs/memory-file-system.ts

@@ -1,102 +0,0 @@
-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 = {}) {
-    super()
-    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())
-  }
-
-  existsSync(path: string): boolean {
-    return this.dirs.has(path) || this.files.has(path)
-  }
-
-  readFileSync(path: string): string {
-    return this.files.get(path) ?? ""
-  }
-
-  writeFileSync(path: string, data: string): void {
-    this.files.set(path, data)
-    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)
-    this.touch(path)
-  }
-
-  unlink(path: string): void {
-    this.files.delete(path)
-    this.mtimes.delete(path)
-    this.modes.delete(path)
-  }
-
-  mkdirSync(path: string, options?: { recursive?: boolean }): void {
-    void options
-    this.dirs.add(path)
-  }
-
-  readdirSync(path: string): string[] {
-    const prefix = path.endsWith("/") ? path : `${path}/`
-    const names: string[] = []
-
-    for (const file of this.files.keys()) {
-      if (!file.startsWith(prefix)) continue
-
-      const rest = file.slice(prefix.length)
-
-      if (!rest.includes("/")) names.push(rest)
-    }
-
-    return names
-  }
-
-  statSync(path: string): FileStat {
-    const mtimeMs = this.mtimes.get(path)
-
-    if (mtimeMs === undefined) {
-      throw new Error(`not found: ${path}`)
-    }
-
-    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/engine/fs/node-file-system.ts

@@ -1,68 +0,0 @@
-import {
-  appendFileSync,
-  chmodSync,
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  statSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs"
-import { type FileStat, FunnelFileSystem } from "@/engine/fs/file-system"
-
-const SECRET_MODE = 0o600
-
-export class NodeFunnelFileSystem extends FunnelFileSystem {
-  constructor() {
-    super()
-    Object.freeze(this)
-  }
-
-  existsSync(path: string): boolean {
-    return existsSync(path)
-  }
-
-  readFileSync(path: string): string {
-    return readFileSync(path, "utf-8")
-  }
-
-  writeFileSync(path: string, data: string): void {
-    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)
-  }
-
-  unlink(path: string): void {
-    try {
-      unlinkSync(path)
-    } catch {
-      // ignore
-    }
-  }
-
-  mkdirSync(path: string, options?: { recursive?: boolean }): void {
-    mkdirSync(path, { recursive: options?.recursive ?? false })
-  }
-
-  readdirSync(path: string): string[] {
-    return readdirSync(path)
-  }
-
-  statSync(path: string): FileStat {
-    const stat = statSync(path)
-
-    return { mtimeMs: stat.mtimeMs, mode: stat.mode & 0o777 }
-  }
-}

package/lib/engine/http/http-client.ts

@@ -1,17 +0,0 @@
-export type HttpRequest = {
-  method: string
-  url: string
-  headers?: Record<string, string>
-  body?: string
-}
-
-export type HttpResponse = {
-  status: number
-  ok: boolean
-  text(): Promise<string>
-  json(): Promise<unknown>
-}
-
-export abstract class FunnelHttpClient {
-  abstract fetch(request: HttpRequest): Promise<HttpResponse>
-}

package/lib/engine/http/memory-http-client.ts

@@ -1,36 +0,0 @@
-import { FunnelHttpClient, type HttpRequest, type HttpResponse } from "@/engine/http/http-client"
-
-export type MemoryHttpResponse = {
-  status?: number
-  body?: string
-}
-
-export type MemoryHttpHandler = (
-  request: HttpRequest,
-) => MemoryHttpResponse | Promise<MemoryHttpResponse>
-
-export class MemoryFunnelHttpClient extends FunnelHttpClient {
-  readonly calls: HttpRequest[] = []
-  private handler: MemoryHttpHandler = () => ({ status: 200, body: "" })
-
-  on(handler: MemoryHttpHandler): this {
-    this.handler = handler
-
-    return this
-  }
-
-  async fetch(request: HttpRequest): Promise<HttpResponse> {
-    this.calls.push(request)
-
-    const response = await this.handler(request)
-    const status = response.status ?? 200
-    const body = response.body ?? ""
-
-    return {
-      status,
-      ok: status >= 200 && status < 300,
-      text: async () => body,
-      json: async () => JSON.parse(body),
-    }
-  }
-}

package/lib/engine/http/node-http-client.ts

@@ -1,23 +0,0 @@
-import { FunnelHttpClient, type HttpRequest, type HttpResponse } from "@/engine/http/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/engine/id/id-generator.ts

@@ -1,7 +0,0 @@
-/**
- * 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

@@ -1,20 +0,0 @@
-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

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

package/lib/engine/logger/logger.ts

@@ -1,11 +0,0 @@
-/**
- * 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

@@ -1,28 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

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