@swarmclawai/swarmclaw 0.2.0

package/src/lib/server/connectors/signal.ts

@@ -0,0 +1,183 @@
+import { spawn, execSync } from 'child_process'
+import type { ChildProcess } from 'child_process'
+import type { Connector } from '@/types'
+import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
+import { isNoMessage } from './manager'
+
+const signal: PlatformConnector = {
+  async start(connector, _botToken, onMessage): Promise<ConnectorInstance> {
+    const phoneNumber = connector.config.phoneNumber
+    if (!phoneNumber) throw new Error('Missing phoneNumber in connector config')
+
+    const cliPath = connector.config.signalCliPath || 'signal-cli'
+    const mode = connector.config.signalCliMode || 'stdio'
+    const httpUrl = connector.config.signalCliHttpUrl || 'http://localhost:8080'
+
+    let stopped = false
+    let daemonProc: ChildProcess | null = null
+    let pollTimer: ReturnType<typeof setInterval> | null = null
+
+    if (mode === 'stdio') {
+      // Spawn signal-cli in daemon mode with JSON output
+      daemonProc = spawn(cliPath, ['-u', phoneNumber, 'daemon', '--json'], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+      })
+
+      let buffer = ''
+
+      daemonProc.stdout?.on('data', (chunk: Buffer) => {
+        buffer += chunk.toString()
+        const lines = buffer.split('\n')
+        buffer = lines.pop() || ''
+
+        for (const line of lines) {
+          if (!line.trim()) continue
+          try {
+            const event = JSON.parse(line)
+            handleSignalEvent(event, connector, onMessage)
+          } catch {
+            // Not valid JSON, skip
+          }
+        }
+      })
+
+      daemonProc.stderr?.on('data', (chunk: Buffer) => {
+        const msg = chunk.toString().trim()
+        if (msg) console.error(`[signal] stderr: ${msg}`)
+      })
+
+      daemonProc.on('exit', (code) => {
+        if (!stopped) {
+          console.error(`[signal] daemon exited unexpectedly with code ${code}`)
+        }
+      })
+
+      console.log(`[signal] Daemon started in stdio mode for ${phoneNumber}`)
+    } else if (mode === 'http') {
+      // Poll the signal-cli REST API for incoming messages
+      const pollInterval = 2000
+
+      const poll = async () => {
+        if (stopped) return
+        try {
+          const res = await fetch(`${httpUrl}/v1/receive/${phoneNumber}`)
+          if (!res.ok) return
+          const messages = await res.json()
+          if (Array.isArray(messages)) {
+            for (const event of messages) {
+              handleSignalEvent(event, connector, onMessage)
+            }
+          }
+        } catch {
+          // Silently retry on connection errors
+        }
+      }
+
+      pollTimer = setInterval(poll, pollInterval)
+      console.log(`[signal] Polling ${httpUrl} for ${phoneNumber} every ${pollInterval}ms`)
+    } else {
+      throw new Error(`Unknown signalCliMode: ${mode}. Use 'stdio' or 'http'.`)
+    }
+
+    return {
+      connector,
+      async sendMessage(channelId, text) {
+        if (stopped) throw new Error('Connector is stopped')
+
+        if (mode === 'http') {
+          const res = await fetch(`${httpUrl}/v2/send`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              message: text,
+              number: phoneNumber,
+              recipients: [channelId],
+            }),
+          })
+          if (!res.ok) {
+            throw new Error(`Signal HTTP send failed: ${res.status} ${res.statusText}`)
+          }
+        } else {
+          // Use signal-cli send command
+          try {
+            execSync(
+              `${cliPath} -u ${phoneNumber} send -m ${JSON.stringify(text)} ${channelId}`,
+              { timeout: 15_000 },
+            )
+          } catch (err: any) {
+            throw new Error(`Signal send failed: ${err.message}`)
+          }
+        }
+      },
+      async stop() {
+        stopped = true
+        if (pollTimer) {
+          clearInterval(pollTimer)
+          pollTimer = null
+        }
+        if (daemonProc) {
+          daemonProc.kill('SIGTERM')
+          daemonProc = null
+        }
+        console.log(`[signal] Connector stopped for ${phoneNumber}`)
+      },
+    }
+  },
+}
+
+/** Parse a signal-cli JSON event and route it as an inbound message */
+export async function handleSignalEvent(
+  event: any,
+  connector: Connector,
+  onMessage: (msg: InboundMessage) => Promise<string>,
+) {
+  // signal-cli JSON output structure varies; handle the common envelope format
+  const envelope = event.envelope || event
+  const dataMessage = envelope.dataMessage
+  if (!dataMessage?.message && !dataMessage?.body) return
+
+  const sender = envelope.source || envelope.sourceNumber || ''
+  const text = dataMessage.message || dataMessage.body || ''
+  const groupId = dataMessage.groupInfo?.groupId || null
+
+  const inbound: InboundMessage = {
+    platform: 'signal',
+    channelId: groupId || sender,
+    channelName: groupId ? `group:${groupId}` : sender,
+    senderId: sender,
+    senderName: envelope.sourceName || sender,
+    text,
+  }
+
+  try {
+    const response = await onMessage(inbound)
+    if (isNoMessage(response)) return
+
+    // Send reply back
+    const cliPath = connector.config.signalCliPath || 'signal-cli'
+    const phoneNumber = connector.config.phoneNumber
+    const mode = connector.config.signalCliMode || 'stdio'
+    const httpUrl = connector.config.signalCliHttpUrl || 'http://localhost:8080'
+
+    if (mode === 'http') {
+      await fetch(`${httpUrl}/v2/send`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          message: response,
+          number: phoneNumber,
+          recipients: [inbound.channelId],
+        }),
+      })
+    } else {
+      execSync(
+        `${cliPath} -u ${phoneNumber} send -m ${JSON.stringify(response)} ${inbound.channelId}`,
+        { timeout: 15_000 },
+      )
+    }
+  } catch (err: any) {
+    console.error(`[signal] Error handling message:`, err.message)
+  }
+}
+
+export default signal

package/src/lib/server/connectors/slack.ts

@@ -0,0 +1,258 @@
+import { App, LogLevel } from '@slack/bolt'
+import fs from 'fs'
+import path from 'path'
+import type { Connector } from '@/types'
+import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
+import { downloadInboundMediaToUpload, inferInboundMediaType, mimeFromPath, isImageMime } from './media'
+import { isNoMessage } from './manager'
+
+const slack: PlatformConnector = {
+  async start(connector, botToken, onMessage): Promise<ConnectorInstance> {
+    const appToken = connector.config.appToken || ''
+    const signingSecret = connector.config.signingSecret || 'not-used-in-socket-mode'
+
+    // Socket Mode requires an app-level token (xapp-...) — without it, Bolt starts an HTTP server
+    if (!appToken) {
+      throw new Error(
+        'App-Level Token (xapp-...) is required. Enable Socket Mode in your Slack app settings ' +
+        'and generate an App-Level Token under Basic Information > App-Level Tokens.'
+      )
+    }
+
+    if (!appToken.startsWith('xapp-')) {
+      throw new Error(
+        `Invalid App-Level Token — must start with "xapp-" (got "${appToken.slice(0, 5)}..."). ` +
+        'The App-Level Token is different from the Bot Token (xoxb-). ' +
+        'Find it under Basic Information > App-Level Tokens in your Slack app settings.'
+      )
+    }
+
+    // Validate the bot token format and auth
+    if (!botToken.startsWith('xoxb-')) {
+      throw new Error(
+        `Invalid Bot Token — must start with "xoxb-" (got "${botToken.slice(0, 5)}..."). ` +
+        'Find it under OAuth & Permissions > Bot User OAuth Token.'
+      )
+    }
+
+    const { WebClient } = await import('@slack/web-api')
+    const testClient = new WebClient(botToken)
+    let botUserId: string | undefined
+    try {
+      const auth = await testClient.auth.test()
+      if (!auth.user_id || !auth.team) {
+        throw new Error('Auth test returned empty — the bot token may be revoked or the app uninstalled')
+      }
+      botUserId = auth.user_id as string
+      console.log(`[slack] Authenticated as @${auth.user} in workspace "${auth.team}"`)
+    } catch (err: any) {
+      const hint = err.code === 'slack_webapi_platform_error'
+        ? '. Check that your Bot Token (xoxb-...) is correct and the app is installed to the workspace.'
+        : ''
+      throw new Error(`Slack auth failed: ${err.message}${hint}`)
+    }
+
+    const app = new App({
+      token: botToken,
+      appToken,
+      signingSecret,
+      socketMode: true,
+      logLevel: LogLevel.WARN,
+    })
+
+    // Catch global errors so they don't become unhandled rejections
+    app.error(async (error) => {
+      console.error(`[slack] App error:`, error)
+    })
+
+    // Optional: restrict to specific channels
+    const allowedChannels = connector.config.channelIds
+      ? connector.config.channelIds.split(',').map((s) => s.trim()).filter(Boolean)
+      : null
+
+    // Handle messages
+    app.message(async ({ message, say, client }) => {
+      // Only handle user messages (not bot messages or own messages)
+      if (!('text' in message) || ('bot_id' in message)) return
+      const msg = message as any
+      if (botUserId && msg.user === botUserId) return
+
+      const channelId = msg.channel
+      if (allowedChannels && !allowedChannels.includes(channelId)) return
+
+      console.log(`[slack] Message in ${channelId} from ${msg.user}: ${(msg.text || '').slice(0, 80)}`)
+
+      // Get user info for display name
+      let senderName = msg.user || 'unknown'
+      try {
+        const userInfo = await client.users.info({ user: msg.user })
+        senderName = userInfo.user?.real_name || userInfo.user?.name || senderName
+      } catch { /* use ID as fallback */ }
+
+      // Get channel name
+      let channelName = channelId
+      try {
+        const channelInfo = await client.conversations.info({ channel: channelId })
+        channelName = (channelInfo.channel as any)?.name || channelId
+      } catch { /* use ID as fallback */ }
+
+      const media: NonNullable<InboundMessage['media']> = []
+      if (Array.isArray(msg.files)) {
+        for (const f of msg.files as any[]) {
+          const mediaType = inferInboundMediaType(f?.mimetype, f?.name, 'document')
+          const sourceUrl = f?.url_private_download || f?.url_private || f?.permalink_public || f?.permalink
+          if (typeof sourceUrl === 'string' && /^https?:\/\//i.test(sourceUrl)) {
+            try {
+              const stored = await downloadInboundMediaToUpload({
+                connectorId: connector.id,
+                mediaType,
+                url: sourceUrl,
+                headers: { Authorization: `Bearer ${botToken}` },
+                fileName: f?.name || undefined,
+                mimeType: f?.mimetype || undefined,
+              })
+              if (stored) {
+                media.push(stored)
+                continue
+              }
+            } catch (err: any) {
+              console.warn(`[slack] Media download failed (${f?.name || 'file'}):`, err?.message || String(err))
+            }
+          }
+          media.push({
+            type: mediaType,
+            fileName: f?.name || undefined,
+            mimeType: f?.mimetype || undefined,
+            sizeBytes: typeof f?.size === 'number' ? f.size : undefined,
+            url: typeof sourceUrl === 'string' ? sourceUrl : undefined,
+          })
+        }
+      }
+
+      const inbound: InboundMessage = {
+        platform: 'slack',
+        channelId,
+        channelName,
+        senderId: msg.user,
+        senderName,
+        text: msg.text || (media.length > 0 ? '(media message)' : ''),
+        imageUrl: media.find((m) => m.type === 'image')?.url,
+        media,
+      }
+
+      try {
+        const response = await onMessage(inbound)
+
+        if (isNoMessage(response)) return
+
+        // Slack has a 4000 char limit for messages
+        if (response.length <= 4000) {
+          await say(response)
+        } else {
+          const chunks = response.match(/[\s\S]{1,3990}/g) || [response]
+          for (const chunk of chunks) {
+            await say(chunk)
+          }
+        }
+      } catch (err: any) {
+        console.error(`[slack] Error handling message:`, err.message)
+        try {
+          await say('Sorry, I encountered an error processing your message.')
+        } catch { /* ignore */ }
+      }
+    })
+
+    // Handle @mentions
+    app.event('app_mention', async ({ event, say, client }) => {
+      if (allowedChannels && !allowedChannels.includes(event.channel)) return
+
+      let senderName = event.user || 'unknown'
+      try {
+        const userInfo = await client.users.info({ user: event.user! })
+        senderName = userInfo.user?.real_name || userInfo.user?.name || senderName
+      } catch { /* use ID */ }
+
+      const inbound: InboundMessage = {
+        platform: 'slack',
+        channelId: event.channel,
+        channelName: event.channel,
+        senderId: event.user || 'unknown',
+        senderName,
+        text: event.text.replace(/<@[^>]+>/g, '').trim(), // Strip @mentions
+      }
+
+      try {
+        const response = await onMessage(inbound)
+        if (isNoMessage(response)) return
+        await say(response)
+      } catch (err: any) {
+        console.error(`[slack] Error handling mention:`, err.message)
+      }
+    })
+
+    await app.start()
+    console.log(`[slack] Bot connected (socket mode)`)
+
+    return {
+      connector,
+      async sendMessage(channelId, text, options) {
+        const webClient = app.client
+
+        // File upload (local path or URL)
+        const hasMedia = options?.mediaPath || options?.imageUrl || options?.fileUrl
+        if (hasMedia) {
+          let fileContent: Buffer | undefined
+          let fileUrl: string | undefined
+          let fileName = options?.fileName || 'attachment'
+
+          if (options?.mediaPath) {
+            if (!fs.existsSync(options.mediaPath)) throw new Error(`File not found: ${options.mediaPath}`)
+            fileContent = fs.readFileSync(options.mediaPath)
+            fileName = options.fileName || path.basename(options.mediaPath)
+          } else {
+            fileUrl = options?.imageUrl || options?.fileUrl
+          }
+
+          if (fileContent) {
+            const result = await webClient.filesUploadV2({
+              channel_id: channelId,
+              file: fileContent,
+              filename: fileName,
+              initial_comment: options?.caption || text || undefined,
+            })
+            return { messageId: (result as any)?.files?.[0]?.id }
+          } else if (fileUrl) {
+            // Send URL as message with unfurl
+            const msg = await webClient.chat.postMessage({
+              channel: channelId,
+              text: `${options?.caption || text || ''}\n${fileUrl}`.trim(),
+              unfurl_links: true,
+              unfurl_media: true,
+            })
+            return { messageId: msg.ts || undefined }
+          }
+        }
+
+        // Text only
+        const payload = text || options?.caption || ''
+        if (payload.length <= 4000) {
+          const msg = await webClient.chat.postMessage({ channel: channelId, text: payload })
+          return { messageId: msg.ts || undefined }
+        }
+        const chunks = payload.match(/[\s\S]{1,3990}/g) || [payload]
+        let lastTs: string | undefined
+        for (const chunk of chunks) {
+          const msg = await webClient.chat.postMessage({ channel: channelId, text: chunk })
+          lastTs = msg.ts || undefined
+        }
+        return { messageId: lastTs }
+      },
+      async stop() {
+        await app.stop()
+        console.log(`[slack] Bot disconnected`)
+      },
+    }
+  },
+}
+
+export default slack

package/src/lib/server/connectors/teams.ts

@@ -0,0 +1,94 @@
+import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
+import { isNoMessage } from './manager'
+
+const teams: PlatformConnector = {
+  async start(connector, botToken, onMessage): Promise<ConnectorInstance> {
+    const pkg = 'botbuilder'
+    const { BotFrameworkAdapter, TurnContext } = await import(/* webpackIgnore: true */ pkg)
+
+    const appId = connector.config.appId
+    if (!appId) throw new Error('Missing appId in connector config')
+
+    const adapter = new BotFrameworkAdapter({
+      appId,
+      appPassword: botToken,
+    })
+
+    adapter.onTurnError = async (_context: unknown, error: Error) => {
+      console.error(`[teams] Turn error:`, error.message)
+    }
+
+    // Store conversation references for proactive messaging
+    const conversationReferences = new Map<string, any>()
+    let stopped = false
+
+    // Process incoming activities — called from the webhook endpoint
+    // POST /api/connectors/[id]/webhook should pipe req/res through this
+    const processActivity = async (req: any, res: any) => {
+      if (stopped) return
+      await adapter.processActivity(req, res, async (context: any) => {
+        if (context.activity.type !== 'message') return
+        if (!context.activity.text) return
+
+        // Save conversation reference for proactive messaging
+        const ref = TurnContext.getConversationReference(context.activity)
+        const convId = context.activity.conversation?.id || ''
+        conversationReferences.set(convId, ref)
+
+        const inbound: InboundMessage = {
+          platform: 'teams',
+          channelId: convId,
+          channelName: context.activity.conversation?.name || convId,
+          senderId: context.activity.from?.id || '',
+          senderName: context.activity.from?.name || 'Unknown',
+          text: context.activity.text || '',
+        }
+
+        try {
+          const response = await onMessage(inbound)
+          if (isNoMessage(response)) return
+          await context.sendActivity(response)
+        } catch (err: any) {
+          console.error(`[teams] Error handling message:`, err.message)
+          try {
+            await context.sendActivity('Sorry, I encountered an error processing your message.')
+          } catch { /* ignore */ }
+        }
+      })
+    }
+
+    // Store processActivity on globalThis so the webhook route can access it
+    const handlerKey = `__swarmclaw_teams_handler_${connector.id}__`
+    ;(globalThis as any)[handlerKey] = processActivity
+
+    console.log(`[teams] Bot registered (appId: ${appId})`)
+    console.log(`[teams] Configure your bot's messaging endpoint to POST to /api/connectors/${connector.id}/webhook`)
+
+    return {
+      connector,
+      async sendMessage(channelId, text) {
+        if (stopped) throw new Error('Connector is stopped')
+
+        const ref = conversationReferences.get(channelId)
+        if (!ref) {
+          throw new Error(`No conversation reference found for ${channelId}. The bot must receive a message first.`)
+        }
+
+        let messageId: string | undefined
+        await adapter.continueConversation(ref, async (context: any) => {
+          const sent = await context.sendActivity(text)
+          messageId = sent?.id
+        })
+        return { messageId }
+      },
+      async stop() {
+        stopped = true
+        delete (globalThis as any)[handlerKey]
+        conversationReferences.clear()
+        console.log(`[teams] Bot disconnected`)
+      },
+    }
+  },
+}
+
+export default teams