@interactive-inc/claude-funnel 0.7.1 → 0.8.1

package/lib/engine/channels/channels.ts

@@ -0,0 +1,520 @@
+import type { CallInput } from "@/connectors/connector-adapter"
+import type { ConnectorConfig } from "@/connectors/connector-config-schema"
+import type { FunnelConnectorFactory } from "@/connectors/connector-factory"
+import type { FunnelConnectorListener } from "@/connectors/connector-listener"
+import type { DiscordConnectorConfig } from "@/connectors/discord-connector-schema"
+import type { GhConnectorConfig } from "@/connectors/gh-connector-schema"
+import type { ScheduleConnectorConfig, ScheduleEntry } from "@/connectors/schedule-connector-schema"
+import type { SlackConnectorConfig } from "@/connectors/slack-connector-schema"
+import type { ProfileChannelChecker } from "@/engine/profiles/profile-channel-checker"
+import { FunnelClock } from "@/engine/time/clock"
+import { NodeFunnelClock } from "@/engine/time/node-clock"
+import { FunnelIdGenerator } from "@/engine/id/id-generator"
+import { NodeFunnelIdGenerator } from "@/engine/id/node-id-generator"
+import { FunnelSettingsReader } from "@/engine/settings/settings-reader"
+import type {
+  ChannelConfig,
+  ChannelDeliveryMode,
+  Settings,
+} from "@/engine/settings/settings-schema"
+
+type Deps = {
+  store: FunnelSettingsReader
+  factory: FunnelConnectorFactory
+  profileChecker: ProfileChannelChecker
+  clock?: FunnelClock
+  idGenerator?: FunnelIdGenerator
+}
+
+export type ChannelConnectorView = ConnectorConfig & {
+  channelId: string
+  channelName: string
+}
+
+type AddConnectorInput =
+  | { type: "slack"; name: string; botToken: string; appToken: string }
+  | { type: "gh"; name: string; pollInterval?: number }
+  | { type: "discord"; name: string; botToken: string }
+  | { type: "schedule"; name: string; entries?: ScheduleEntry[] }
+
+const defaultClock = new NodeFunnelClock()
+const defaultIdGenerator = new NodeFunnelIdGenerator()
+
+/**
+ * Channels own their connectors. Each channel has a stable id (UUID); the
+ * `name` is the human-facing label used by the CLI. Connectors live nested
+ * inside `channel.connectors[]`, so add/remove/rename are channel-scoped — no
+ * global connector namespace exists. Token uniqueness is enforced across all
+ * channels at add/update time so the same Slack/Discord credentials cannot
+ * be registered twice.
+ */
+export class FunnelChannels {
+  private readonly store: FunnelSettingsReader
+  private readonly factory: FunnelConnectorFactory
+  private readonly profileChecker: ProfileChannelChecker
+  private readonly clock: FunnelClock
+  private readonly idGenerator: FunnelIdGenerator
+
+  constructor(deps: Deps) {
+    this.store = deps.store
+    this.factory = deps.factory
+    this.profileChecker = deps.profileChecker
+    this.clock = deps.clock ?? defaultClock
+    this.idGenerator = deps.idGenerator ?? defaultIdGenerator
+    Object.freeze(this)
+  }
+
+  list(): ChannelConfig[] {
+    return this.store.read().channels
+  }
+
+  get(name: string): ChannelConfig | null {
+    return this.list().find((c) => c.name === name) ?? null
+  }
+
+  getById(id: string): ChannelConfig | null {
+    return this.list().find((c) => c.id === id) ?? null
+  }
+
+  add(input: { name: string; delivery?: ChannelDeliveryMode }): ChannelConfig {
+    const settings = this.store.read()
+
+    if (settings.channels.some((c) => c.name === input.name)) {
+      throw new Error(`channel "${input.name}" already exists`)
+    }
+
+    const channel: ChannelConfig = {
+      id: this.idGenerator.generate(),
+      name: input.name,
+      delivery: input.delivery ?? "fanout",
+      connectors: [],
+    }
+
+    settings.channels.push(channel)
+    this.store.write(settings)
+
+    return channel
+  }
+
+  setDelivery(name: string, delivery: ChannelDeliveryMode): void {
+    const settings = this.store.read()
+    const channel = this.requireChannel(settings, name)
+
+    channel.delivery = delivery
+
+    this.store.write(settings)
+  }
+
+  remove(name: string): void {
+    const settings = this.store.read()
+    const index = settings.channels.findIndex((c) => c.name === name)
+
+    if (index < 0) throw new Error(`channel "${name}" not found`)
+
+    const channel = settings.channels[index]
+
+    if (channel && this.profileChecker.hasChannelRef(channel.id)) {
+      throw new Error(`channel "${name}" is referenced by a profile`)
+    }
+
+    settings.channels.splice(index, 1)
+    this.store.write(settings)
+  }
+
+  rename(oldName: string, newName: string): void {
+    const settings = this.store.read()
+    const channel = settings.channels.find((c) => c.name === oldName)
+
+    if (!channel) throw new Error(`channel "${oldName}" not found`)
+    if (settings.channels.some((c) => c.name === newName)) {
+      throw new Error(`channel "${newName}" already exists`)
+    }
+
+    channel.name = newName
+    this.store.write(settings)
+  }
+
+  listConnectors(channelName: string): ConnectorConfig[] {
+    return this.requireChannel(this.store.read(), channelName).connectors
+  }
+
+  getConnector(channelName: string, connectorName: string): ConnectorConfig | null {
+    const channel = this.get(channelName)
+
+    if (!channel) return null
+
+    return channel.connectors.find((c) => c.name === connectorName) ?? null
+  }
+
+  listAllConnectors(): ChannelConnectorView[] {
+    const out: ChannelConnectorView[] = []
+
+    for (const channel of this.list()) {
+      for (const connector of channel.connectors) {
+        out.push({ ...connector, channelId: channel.id, channelName: channel.name })
+      }
+    }
+
+    return out
+  }
+
+  addConnector(channelName: string, input: AddConnectorInput): ConnectorConfig {
+    const settings = this.store.read()
+    const channel = this.requireChannel(settings, channelName)
+
+    if (channel.connectors.some((c) => c.name === input.name)) {
+      throw new Error(`connector "${input.name}" already exists in channel "${channelName}"`)
+    }
+
+    const candidate = this.fromInput(input)
+
+    this.assertNoTokenCollision(settings, candidate)
+
+    channel.connectors.push(candidate)
+    this.store.write(settings)
+
+    return candidate
+  }
+
+  private fromInput(input: AddConnectorInput): ConnectorConfig {
+    const id = this.idGenerator.generate()
+    const now = this.clock.iso()
+    const createdAt = now
+    const updatedAt = now
+
+    if (input.type === "slack") {
+      return {
+        id,
+        type: "slack",
+        name: input.name,
+        botToken: input.botToken,
+        appToken: input.appToken,
+        createdAt,
+        updatedAt,
+      }
+    }
+
+    if (input.type === "gh") {
+      return {
+        id,
+        type: "gh",
+        name: input.name,
+        ...(input.pollInterval !== undefined ? { pollInterval: input.pollInterval } : {}),
+        createdAt,
+        updatedAt,
+      }
+    }
+
+    if (input.type === "discord") {
+      return {
+        id,
+        type: "discord",
+        name: input.name,
+        botToken: input.botToken,
+        createdAt,
+        updatedAt,
+      }
+    }
+
+    return {
+      id,
+      type: "schedule",
+      name: input.name,
+      entries: input.entries ?? [],
+      createdAt,
+      updatedAt,
+    }
+  }
+
+  removeConnector(channelName: string, connectorName: string): void {
+    const settings = this.store.read()
+    const channel = this.requireChannel(settings, channelName)
+    const index = channel.connectors.findIndex((c) => c.name === connectorName)
+
+    if (index < 0) {
+      throw new Error(`connector "${connectorName}" not found in channel "${channelName}"`)
+    }
+
+    channel.connectors.splice(index, 1)
+    this.store.write(settings)
+  }
+
+  renameConnector(channelName: string, oldName: string, newName: string): void {
+    const settings = this.store.read()
+    const channel = this.requireChannel(settings, channelName)
+    const connector = channel.connectors.find((c) => c.name === oldName)
+
+    if (!connector) {
+      throw new Error(`connector "${oldName}" not found in channel "${channelName}"`)
+    }
+
+    if (channel.connectors.some((c) => c.name === newName)) {
+      throw new Error(`connector "${newName}" already exists in channel "${channelName}"`)
+    }
+
+    connector.name = newName
+    connector.updatedAt = this.clock.iso()
+    this.store.write(settings)
+  }
+
+  updateSlackConnector(
+    channelName: string,
+    connectorName: string,
+    fields: { botToken?: string; appToken?: string },
+  ): void {
+    const settings = this.store.read()
+    const channel = this.requireChannel(settings, channelName)
+    const connector = this.requireSlackConnector(channel, connectorName)
+
+    const updated: SlackConnectorConfig = {
+      ...connector,
+      botToken: fields.botToken ?? connector.botToken,
+      appToken: fields.appToken ?? connector.appToken,
+      updatedAt: this.clock.iso(),
+    }
+
+    this.assertNoTokenCollision(settings, updated)
+
+    Object.assign(connector, updated)
+    this.store.write(settings)
+  }
+
+  updateGhConnector(
+    channelName: string,
+    connectorName: string,
+    fields: { pollInterval?: number },
+  ): void {
+    const settings = this.store.read()
+    const channel = this.requireChannel(settings, channelName)
+    const connector = this.requireGhConnector(channel, connectorName)
+
+    if (fields.pollInterval !== undefined) connector.pollInterval = fields.pollInterval
+    connector.updatedAt = this.clock.iso()
+
+    this.store.write(settings)
+  }
+
+  updateDiscordConnector(
+    channelName: string,
+    connectorName: string,
+    fields: { botToken?: string },
+  ): void {
+    const settings = this.store.read()
+    const channel = this.requireChannel(settings, channelName)
+    const connector = this.requireDiscordConnector(channel, connectorName)
+
+    const updated: DiscordConnectorConfig = {
+      ...connector,
+      botToken: fields.botToken ?? connector.botToken,
+      updatedAt: this.clock.iso(),
+    }
+
+    this.assertNoTokenCollision(settings, updated)
+
+    Object.assign(connector, updated)
+    this.store.write(settings)
+  }
+
+  listScheduleEntries(channelName: string, connectorName: string): ScheduleEntry[] {
+    const channel = this.requireChannel(this.store.read(), channelName)
+    const connector = this.requireScheduleConnector(channel, connectorName)
+
+    return connector.entries
+  }
+
+  addScheduleEntry(
+    channelName: string,
+    connectorName: string,
+    entry: Pick<ScheduleEntry, "cron" | "prompt"> &
+      Partial<Pick<ScheduleEntry, "id" | "enabled" | "catchupPolicy">>,
+  ): ScheduleEntry {
+    const settings = this.store.read()
+    const channel = this.requireChannel(settings, channelName)
+    const connector = this.requireScheduleConnector(channel, connectorName)
+
+    const persisted: ScheduleEntry = {
+      id: entry.id ?? this.idGenerator.generate(),
+      cron: entry.cron,
+      prompt: entry.prompt,
+      enabled: entry.enabled ?? true,
+      catchupPolicy: entry.catchupPolicy ?? "latest",
+    }
+
+    connector.entries.push(persisted)
+    connector.updatedAt = this.clock.iso()
+    this.store.write(settings)
+
+    return persisted
+  }
+
+  removeScheduleEntry(channelName: string, connectorName: string, id: string): void {
+    const settings = this.store.read()
+    const channel = this.requireChannel(settings, channelName)
+    const connector = this.requireScheduleConnector(channel, connectorName)
+    const index = connector.entries.findIndex((e) => e.id === id)
+
+    if (index < 0) throw new Error(`schedule entry "${id}" not found`)
+
+    connector.entries.splice(index, 1)
+    connector.updatedAt = this.clock.iso()
+    this.store.write(settings)
+  }
+
+  async call(channelName: string, connectorName: string, input: CallInput): Promise<unknown> {
+    const connector = this.getConnector(channelName, connectorName)
+
+    if (!connector) {
+      throw new Error(`connector "${connectorName}" not found in channel "${channelName}"`)
+    }
+
+    const adapter = this.factory.createAdapter(connector)
+
+    if (!adapter) {
+      throw new Error(`connector type "${connector.type}" does not support outbound calls`)
+    }
+
+    return await adapter.call(input)
+  }
+
+  createListener(
+    channelName: string,
+    connectorName: string,
+  ): { config: ConnectorConfig; channelId: string; listener: FunnelConnectorListener } | null {
+    const channel = this.get(channelName)
+
+    if (!channel) return null
+
+    const connector = channel.connectors.find((c) => c.name === connectorName)
+
+    if (!connector) return null
+
+    return {
+      config: connector,
+      channelId: channel.id,
+      listener: this.factory.createListener(channel.id, connector),
+    }
+  }
+
+  createAllListeners(): {
+    config: ConnectorConfig
+    channelId: string
+    channelName: string
+    listener: FunnelConnectorListener
+  }[] {
+    const out: {
+      config: ConnectorConfig
+      channelId: string
+      channelName: string
+      listener: FunnelConnectorListener
+    }[] = []
+
+    for (const channel of this.list()) {
+      for (const connector of channel.connectors) {
+        out.push({
+          config: connector,
+          channelId: channel.id,
+          channelName: channel.name,
+          listener: this.factory.createListener(channel.id, connector),
+        })
+      }
+    }
+
+    return out
+  }
+
+  private requireChannel(settings: Settings, name: string): ChannelConfig {
+    const channel = settings.channels.find((c) => c.name === name)
+
+    if (!channel) throw new Error(`channel "${name}" not found`)
+
+    return channel
+  }
+
+  private requireConnector(channel: ChannelConfig, connectorName: string): ConnectorConfig {
+    const connector = channel.connectors.find((c) => c.name === connectorName)
+
+    if (!connector) {
+      throw new Error(`connector "${connectorName}" not found in channel "${channel.name}"`)
+    }
+
+    return connector
+  }
+
+  private requireSlackConnector(
+    channel: ChannelConfig,
+    connectorName: string,
+  ): SlackConnectorConfig {
+    const connector = this.requireConnector(channel, connectorName)
+
+    if (connector.type !== "slack") {
+      throw new Error(`connector "${connectorName}" is type "${connector.type}", not "slack"`)
+    }
+
+    return connector
+  }
+
+  private requireGhConnector(channel: ChannelConfig, connectorName: string): GhConnectorConfig {
+    const connector = this.requireConnector(channel, connectorName)
+
+    if (connector.type !== "gh") {
+      throw new Error(`connector "${connectorName}" is type "${connector.type}", not "gh"`)
+    }
+
+    return connector
+  }
+
+  private requireDiscordConnector(
+    channel: ChannelConfig,
+    connectorName: string,
+  ): DiscordConnectorConfig {
+    const connector = this.requireConnector(channel, connectorName)
+
+    if (connector.type !== "discord") {
+      throw new Error(`connector "${connectorName}" is type "${connector.type}", not "discord"`)
+    }
+
+    return connector
+  }
+
+  private requireScheduleConnector(
+    channel: ChannelConfig,
+    connectorName: string,
+  ): ScheduleConnectorConfig {
+    const connector = this.requireConnector(channel, connectorName)
+
+    if (connector.type !== "schedule") {
+      throw new Error(`connector "${connectorName}" is type "${connector.type}", not "schedule"`)
+    }
+
+    return connector
+  }
+
+  private assertNoTokenCollision(settings: Settings, candidate: ConnectorConfig): void {
+    const tokens = this.tokensOf(candidate)
+
+    if (tokens.length === 0) return
+
+    for (const channel of settings.channels) {
+      for (const other of channel.connectors) {
+        if (other.id === candidate.id) continue
+
+        for (const token of this.tokensOf(other)) {
+          if (tokens.includes(token)) {
+            throw new Error(
+              `token already in use by connector "${other.name}" in channel "${channel.name}"`,
+            )
+          }
+        }
+      }
+    }
+  }
+
+  private tokensOf(connector: ConnectorConfig): string[] {
+    if (connector.type === "slack") return [connector.botToken, connector.appToken]
+    if (connector.type === "discord") return [connector.botToken]
+
+    return []
+  }
+}
+
+export type { ScheduleConnectorConfig }

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