@rokrokss/claude-slack-channel 0.1.0

package/lib/formatting.ts

@@ -0,0 +1,73 @@
+export function fixSlackMrkdwn(text: string): string {
+  return text.replace(/\*([^*]+)\*/g, '\u200B*$1*\u200B')
+}
+
+export function extractMessageText(msg: Record<string, any>): string {
+  const parts: string[] = []
+
+  if (msg.blocks) {
+    for (const block of msg.blocks) {
+      if (block.type === 'rich_text' && block.elements) {
+        for (const elem of block.elements) {
+          if (elem.elements) {
+            parts.push(elem.elements.map((e: any) => e.text ?? '').join(''))
+          }
+        }
+      } else if (block.type === 'section') {
+        if (block.text?.text) parts.push(block.text.text)
+        if (block.fields) {
+          parts.push(block.fields.map((f: any) => f.text ?? '').join(' '))
+        }
+      } else if (block.type === 'header') {
+        if (block.text?.text) parts.push(`*${block.text.text}*`)
+      } else if (block.type === 'context' && block.elements) {
+        const texts = block.elements.map((e: any) => e.text ?? '').filter(Boolean)
+        if (texts.length) parts.push(texts.join(' '))
+      } else if (block.type === 'divider') {
+        parts.push('---')
+      } else if (block.type === 'image') {
+        parts.push(block.alt_text || block.title?.text || '[image]')
+      } else if (block.text?.text) {
+        parts.push(block.text.text)
+      }
+    }
+  }
+
+  if (parts.length > 0) return parts.join('\n')
+
+  if (msg.text) return msg.text
+
+  if (msg.attachments) {
+    for (const att of msg.attachments) {
+      const attParts: string[] = []
+      if (att.blocks) {
+        const inner = extractMessageText({ blocks: att.blocks })
+        if (inner) attParts.push(inner)
+      }
+      if (att.pretext) attParts.push(att.pretext)
+      if (att.title && att.title_link) {
+        attParts.push(`<${att.title_link}|${att.title}>`)
+      } else if (att.title) {
+        attParts.push(att.title)
+      }
+      if (att.text) attParts.push(att.text)
+      if (att.fields) {
+        for (const f of att.fields) {
+          if (f.title || f.value) attParts.push(`${f.title ?? ''}: ${f.value ?? ''}`)
+        }
+      }
+      if (att.image_url) attParts.push(`[image: ${att.image_url}]`)
+      if (attParts.length === 0 && att.from_url) attParts.push(att.from_url)
+      if (attParts.length === 0 && att.fallback) attParts.push(att.fallback)
+      if (attParts.length > 0) parts.push(attParts.join('\n'))
+    }
+  }
+
+  if (parts.length > 0) return parts.join('\n')
+
+  if (msg.files) {
+    return msg.files.map((f: any) => `[file: ${f.name || f.title || f.id}]`).join(', ')
+  }
+
+  return msg.text || ''
+}

package/lib/gate.ts

@@ -0,0 +1,47 @@
+export interface Access {
+  allowFrom: string[]
+  ackReaction?: string
+  botOwner?: string
+}
+
+export interface GateResult {
+  action: 'deliver' | 'drop'
+  access?: Access
+}
+
+export interface GateOptions {
+  access: Access
+  botUserId: string
+}
+
+export function defaultAccess(): Access {
+  return { allowFrom: [] }
+}
+
+/**
+ * Check if the MCP client supports the channel capability.
+ */
+export function clientSupportsChannels(capabilities: Record<string, unknown> | undefined): boolean {
+  if (!capabilities) return false
+  const experimental = capabilities['experimental']
+  if (!experimental || typeof experimental !== 'object') return false
+  return 'claude/channel' in experimental
+}
+
+export function gate(event: unknown, opts: GateOptions): GateResult {
+  const ev = event as Record<string, unknown>
+
+  if (ev['user'] && ev['user'] === opts.botUserId) return { action: 'drop' }
+  if (ev['subtype'] && ev['subtype'] !== 'file_share' && ev['subtype'] !== 'bot_message') {
+    return { action: 'drop' }
+  }
+  if (ev['subtype'] === 'bot_message') return { action: 'deliver', access: opts.access }
+  if (!ev['user']) return { action: 'drop' }
+  if (opts.access.botOwner && ev['user'] === opts.access.botOwner) {
+    return { action: 'deliver', access: opts.access }
+  }
+  if (opts.access.allowFrom.includes(ev['user'] as string)) {
+    return { action: 'deliver', access: opts.access }
+  }
+  return { action: 'drop' }
+}

package/lib/index.ts

@@ -0,0 +1,7 @@
+export * from './gate.ts'
+export * from './security.ts'
+export * from './formatting.ts'
+export * from './audit.ts'
+export * from './event.ts'
+export * from './resilience.ts'
+export * from './permalink.ts'

package/lib/permalink.ts

@@ -0,0 +1,8 @@
+export function buildPermalink(workspace: string, channel: string, ts: string, threadTs?: string): string {
+  const tsNoDot = ts.replace('.', '')
+  const base = `https://${workspace}.slack.com/archives/${channel}/p${tsNoDot}`
+  if (threadTs) {
+    return `${base}?thread_ts=${threadTs}&cid=${channel}`
+  }
+  return base
+}

package/lib/resilience.ts

@@ -0,0 +1,45 @@
+import { DEFAULT_STALE_THRESHOLD_MS } from './event.ts'
+
+export class EventDeduplicator {
+  private seen = new Map<string, number>()
+  private readonly ttlMs: number
+  private readonly cleanupInterval: number
+
+  private callCount = 0
+
+  constructor(ttlMs: number = DEFAULT_STALE_THRESHOLD_MS, cleanupInterval: number = 100) {
+    this.ttlMs = ttlMs
+    this.cleanupInterval = cleanupInterval
+  }
+
+  /** Returns true if this event was already seen (duplicate). */
+  isDuplicate(channel: string, ts: string): boolean {
+    const key = `${channel}:${ts}`
+    const now = Date.now()
+
+    // Periodic cleanup
+    if (++this.callCount % this.cleanupInterval === 0) {
+      this.cleanup(now)
+    }
+
+    const existing = this.seen.get(key)
+    if (existing !== undefined && now - existing < this.ttlMs) {
+      return true
+    }
+
+    this.seen.set(key, now)
+    return false
+  }
+
+  private cleanup(now: number): void {
+    for (const [key, timestamp] of this.seen) {
+      if (now - timestamp >= this.ttlMs) {
+        this.seen.delete(key)
+      }
+    }
+  }
+
+  get size(): number {
+    return this.seen.size
+  }
+}

package/lib/security.ts

@@ -0,0 +1,9 @@
+export function assertOutboundAllowed(
+  chatId: string,
+  deliveredChannels: ReadonlySet<string>,
+): void {
+  if (deliveredChannels.has(chatId)) return
+  throw new Error(
+    `Outbound gate: channel ${chatId} has not received any inbound messages.`,
+  )
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@rokrokss/claude-slack-channel",
+  "version": "0.1.0",
+  "description": "Two-way Slack channel for Claude Code — Slack DM과 채널 멘션으로 Claude Code 세션과 대화",
+  "type": "module",
+  "bin": "./server.ts",
+  "scripts": {
+    "start": "bun server.ts",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@slack/socket-mode": "^2.0.0",
+    "@slack/web-api": "^7.0.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.0.0",
+    "typescript": "^5.4.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rokrokss/claude-slack-channel.git"
+  }
+}