@interactive-inc/claude-funnel 0.4.1 → 0.8.0

package/lib/connectors/slack-adapter.ts

@@ -0,0 +1,36 @@
+import { WebClient } from "@slack/web-api"
+import { FunnelConnectorAdapter, type CallInput } from "@/connectors/connector-adapter"
+import type { SlackConnectorConfig } from "@/connectors/slack-connector-schema"
+
+export type SlackWebClientLike = {
+  apiCall: (method: string, options?: Record<string, unknown>) => Promise<unknown>
+}
+
+const toRecord = (value: object): Record<string, unknown> => {
+  const result: Record<string, unknown> = {}
+
+  for (const [key, val] of Object.entries(value)) result[key] = val
+
+  return result
+}
+
+type Deps = {
+  config: SlackConnectorConfig
+  client?: SlackWebClientLike
+}
+
+export class FunnelSlackAdapter extends FunnelConnectorAdapter {
+  private readonly client: SlackWebClientLike
+
+  constructor(deps: Deps) {
+    super()
+    this.client = deps.client ?? new WebClient(deps.config.botToken)
+    Object.freeze(this)
+  }
+
+  async call(input: CallInput): Promise<unknown> {
+    const body = input.body !== null && typeof input.body === "object" ? toRecord(input.body) : {}
+
+    return await this.client.apiCall(input.path, body)
+  }
+}

package/lib/{modules/connectors → connectors}/slack-connector-schema.ts

@@ -1,10 +1,13 @@
 import { z } from "zod"
 
 export const slackConnectorSchema = z.object({
-  type: z.literal("slack"),
+  id: z.string(),
   name: z.string(),
+  type: z.literal("slack"),
   botToken: z.string().startsWith("xoxb-"),
   appToken: z.string().startsWith("xapp-"),
+  createdAt: z.string().datetime().optional(),
+  updatedAt: z.string().datetime().optional(),
 })
 
 export type SlackConnectorConfig = z.infer<typeof slackConnectorSchema>

package/lib/{modules/connectors/funnel-slack-event-processor.ts → connectors/slack-event-processor.ts}

@@ -29,6 +29,12 @@ type Props = {
   now?: () => number
 }
 
+const getString = (event: SlackRawEvent, key: string): string | undefined => {
+  const value = event[key]
+
+  return typeof value === "string" ? value : undefined
+}
+
 export class FunnelSlackEventProcessor {
   private readonly ownBotUserId: string
   private readonly ownBotId: string
@@ -42,16 +48,16 @@ export class FunnelSlackEventProcessor {
   }
 
   process(event: SlackRawEvent): SlackProcessed {
-    const eventType = event.type as string | undefined
+    const eventType = getString(event, "type")
 
     if (!eventType || !ALLOWED_EVENTS.has(eventType)) return { skip: true }
 
-    const subtype = event.subtype as string | undefined
+    const subtype = getString(event, "subtype")
 
     if (!ALLOWED_SUBTYPES.has(subtype)) return { skip: true }
 
-    const channelId = (event.channel as string) ?? ""
-    const eventTs = (event.event_ts as string) ?? (event.ts as string) ?? ""
+    const channelId = getString(event, "channel") ?? ""
+    const eventTs = getString(event, "event_ts") ?? getString(event, "ts") ?? ""
     const dedupKey = `${channelId}:${eventTs}`
     const now = this.now()
 
@@ -63,15 +69,15 @@ export class FunnelSlackEventProcessor {
       if ((this.dedup.get(key) ?? 0) < now - DEDUP_WINDOW) this.dedup.delete(key)
     }
 
-    const userId = event.user as string | undefined
-    const botId = event.bot_id as string | undefined
+    const userId = getString(event, "user")
+    const botId = getString(event, "bot_id")
 
     if (userId === this.ownBotUserId) return { skip: true }
     if (botId === this.ownBotId) return { skip: true }
 
-    const text = (event.text as string) ?? ""
+    const text = getString(event, "text") ?? ""
     const mentioned = text.includes(`<@${this.ownBotUserId}>`)
-    const threadTs = (event.thread_ts as string) ?? (event.ts as string) ?? ""
+    const threadTs = getString(event, "thread_ts") ?? getString(event, "ts") ?? ""
 
     return {
       skip: false,
@@ -85,7 +91,7 @@ export class FunnelSlackEventProcessor {
       },
       shouldReact: mentioned,
       channel: channelId,
-      timestamp: (event.ts as string) ?? "",
+      timestamp: getString(event, "ts") ?? "",
     }
   }
 }

package/lib/{modules/connectors/funnel-slack-listener.ts → connectors/slack-listener.ts}

@@ -1,23 +1,31 @@
 import { App, LogLevel } from "@slack/bolt"
-import {
-  FunnelConnectorListener,
-  type NotifyFn,
-} from "@/modules/connectors/funnel-connector-listener"
-import { FunnelSlackEventProcessor } from "@/modules/connectors/funnel-slack-event-processor"
-import { logger } from "@/modules/logger"
-import type { SlackConnectorConfig } from "@/modules/connectors/slack-connector-schema"
+import { z } from "zod"
+import { FunnelConnectorListener, type NotifyFn } from "@/connectors/connector-listener"
+import { FunnelSlackEventProcessor } from "@/connectors/slack-event-processor"
+import { FunnelLogger } from "@/engine/logger/logger"
+import { NodeFunnelLogger } from "@/engine/logger/node-logger"
+import type { SlackConnectorConfig } from "@/connectors/slack-connector-schema"
+
+const middlewareArgsSchema = z.object({
+  event: z.record(z.string(), z.unknown()).optional(),
+})
 
 type Deps = {
   config: SlackConnectorConfig
+  logger?: FunnelLogger
 }
 
+const defaultLogger = new NodeFunnelLogger()
+
 export class FunnelSlackListener extends FunnelConnectorListener {
   private readonly config: SlackConnectorConfig
+  private readonly logger: FunnelLogger
+  private app: App | null = null
 
   constructor(deps: Deps) {
     super()
     this.config = deps.config
-    Object.freeze(this)
+    this.logger = deps.logger ?? defaultLogger
   }
 
   async start(notify: NotifyFn): Promise<void> {
@@ -35,13 +43,11 @@ export class FunnelSlackListener extends FunnelConnectorListener {
     })
 
     app.use(async (args) => {
-      const event = (args as unknown as Record<string, unknown>).event as
-        | Record<string, unknown>
-        | undefined
+      const parsed = middlewareArgsSchema.safeParse(args)
 
-      if (!event) return
+      if (!parsed.success || !parsed.data.event) return
 
-      const result = processor.process(event)
+      const result = processor.process(parsed.data.event)
 
       if (result.skip) return
 
@@ -62,11 +68,30 @@ export class FunnelSlackListener extends FunnelConnectorListener {
     })
 
     app.error(async (error) => {
-      logger.error("Slack error", {
+      this.logger.error("Slack error", {
         error: error instanceof Error ? error.message : String(error),
       })
     })
 
     await app.start()
+    this.app = app
+  }
+
+  async stop(): Promise<void> {
+    if (!this.app) return
+
+    try {
+      await this.app.stop()
+    } catch (error) {
+      this.logger.error("Slack stop error", {
+        error: error instanceof Error ? error.message : String(error),
+      })
+    } finally {
+      this.app = null
+    }
+  }
+
+  override isAlive(): boolean {
+    return this.app !== null
   }
 }