@swarmclawai/swarmclaw 0.8.4 → 0.8.7

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

@@ -0,0 +1,142 @@
+import type { Connector, MessageSource } from '@/types'
+import { loadConnectors } from '../storage'
+import { notify } from '../ws-hub'
+import { resolveConnectorSessionPolicy, shouldReplyToInboundMessage } from './policy'
+import { runningConnectors } from './runtime-state'
+import { findDirectSessionForInbound, persistSessionRecord } from './session'
+import type { InboundMessage } from './types'
+
+export function getConnectorReplySendOptions(params: {
+  connectorId: string
+  inbound: InboundMessage
+}): { replyToMessageId?: string; threadId?: string } {
+  const connectors = loadConnectors()
+  const connector = connectors[params.connectorId] as Connector | undefined
+  if (!connector) return {}
+  const session = findDirectSessionForInbound(connector, params.inbound)
+  const policy = resolveConnectorSessionPolicy(connector, params.inbound, session)
+  return shouldReplyToInboundMessage({
+    msg: params.inbound,
+    session,
+    policy,
+  })
+}
+
+export function statusReactionForPlatform(platform: string, state: 'processing' | 'sent' | 'silent'): string {
+  if (platform === 'slack') {
+    if (state === 'processing') return 'eyes'
+    if (state === 'sent') return 'white_check_mark'
+    return 'zipper_mouth_face'
+  }
+  if (state === 'processing') return '👀'
+  if (state === 'sent') return '✅'
+  return '🤐'
+}
+
+export async function maybeSendStatusReaction(
+  connector: Connector,
+  msg: InboundMessage,
+  state: 'processing' | 'sent' | 'silent',
+): Promise<void> {
+  if (!msg.messageId) return
+  const session = findDirectSessionForInbound(connector, msg)
+  const policy = resolveConnectorSessionPolicy(connector, msg, session)
+  if (!policy.statusReactions) return
+  const instance = runningConnectors.get(connector.id)
+  if (!instance?.sendReaction) return
+  try {
+    await instance.sendReaction(msg.channelId, msg.messageId, statusReactionForPlatform(connector.platform, state))
+  } catch {
+    // Status reactions are best-effort only.
+  }
+}
+
+export async function recordConnectorOutboundDelivery(params: {
+  connectorId: string
+  inbound: InboundMessage
+  messageId?: string
+  state?: 'sent' | 'silent'
+}): Promise<void> {
+  const connectors = loadConnectors()
+  const connector = connectors[params.connectorId] as Connector | undefined
+  if (!connector) return
+  const session = findDirectSessionForInbound(connector, params.inbound)
+  if (session) {
+    session.connectorContext = {
+      ...(session.connectorContext || {}),
+      lastOutboundAt: Date.now(),
+      lastOutboundMessageId: params.messageId || session.connectorContext?.lastOutboundMessageId || null,
+      threadId: params.inbound.threadId || session.connectorContext?.threadId || null,
+    }
+    const history = Array.isArray(session.messages) ? session.messages : []
+    for (let i = history.length - 1; i >= 0; i -= 1) {
+      const entry = history[i]
+      if (entry?.role !== 'assistant') continue
+      const source: Partial<MessageSource> = entry?.source || {}
+      if (source.connectorId !== connector.id) continue
+      if (source.channelId !== params.inbound.channelId) continue
+      if (!source.messageId && params.messageId) {
+        entry.source = {
+          platform: source.platform || connector.platform,
+          connectorId: source.connectorId || connector.id,
+          connectorName: source.connectorName || connector.name,
+          channelId: source.channelId || params.inbound.channelId,
+          senderId: source.senderId,
+          senderName: source.senderName,
+          messageId: params.messageId,
+          replyToMessageId: source.replyToMessageId || params.inbound.messageId,
+          threadId: source.threadId || params.inbound.threadId,
+        }
+      }
+      break
+    }
+    persistSessionRecord(session)
+    notify(`messages:${session.id}`)
+  }
+  if (params.state) {
+    await maybeSendStatusReaction(connector, params.inbound, params.state)
+  }
+}
+
+export function splitConnectorText(text: string, maxChunkLength: number): string[] {
+  if (!text) return ['']
+  if (text.length <= maxChunkLength) return [text]
+  return text.match(new RegExp(`[\\s\\S]{1,${Math.max(1, maxChunkLength)}}`, 'g')) || [text]
+}
+
+export async function deliverChunkedConnectorText(params: {
+  connectorId: string
+  inbound: InboundMessage
+  text: string
+  maxSingleMessageLength: number
+  chunkLength: number
+  sendChunk: (
+    chunk: string,
+    meta: { isFirstChunk: boolean; replyToMessageId?: string; threadId?: string },
+  ) => Promise<string | undefined>
+}): Promise<string | undefined> {
+  const replyOptions = getConnectorReplySendOptions({
+    connectorId: params.connectorId,
+    inbound: params.inbound,
+  })
+  const chunks = params.text.length <= params.maxSingleMessageLength
+    ? [params.text]
+    : splitConnectorText(params.text, params.chunkLength)
+
+  let lastMessageId: string | undefined
+  for (let index = 0; index < chunks.length; index += 1) {
+    lastMessageId = await params.sendChunk(chunks[index], {
+      isFirstChunk: index === 0,
+      replyToMessageId: replyOptions.replyToMessageId,
+      threadId: replyOptions.threadId,
+    })
+  }
+
+  await recordConnectorOutboundDelivery({
+    connectorId: params.connectorId,
+    inbound: params.inbound,
+    messageId: lastMessageId,
+    state: 'sent',
+  })
+  return lastMessageId
+}

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

@@ -3,8 +3,10 @@ import fs from 'fs'
 import path from 'path'
 import type { Connector } from '@/types'
 import type { PlatformConnector, ConnectorInstance, InboundMessage, InboundThreadHistoryEntry } from './types'
+import { resolveConnectorIngressReply } from './ingress-delivery'
+import { deliverChunkedConnectorText } from './delivery'
 import { downloadInboundMediaToUpload, inferInboundMediaType } from './media'
-import { getConnectorReplySendOptions, isNoMessage, recordConnectorOutboundDelivery } from './manager'
+import { errorMessage } from '@/lib/shared-utils'
 
 function buildDiscordThreadTitle(params: {
   threadName?: string
@@ -87,7 +89,7 @@ async function hydrateDiscordThreadContext(message: any, inbound: InboundMessage
       }].filter((entry) => entry.text.trim().length > 0)
     }
   } catch (err: unknown) {
-    console.warn(`[discord] Thread context bootstrap failed: ${err instanceof Error ? err.message : String(err)}`)
+    console.warn(`[discord] Thread context bootstrap failed: ${errorMessage(err)}`)
   }
 }
 
@@ -152,7 +154,7 @@ const discord: PlatformConnector = {
               continue
             }
           } catch (err: unknown) {
-            const errMsg = err instanceof Error ? err.message : String(err)
+            const errMsg = errorMessage(err)
             console.warn(`[discord] Media download failed (${attachment.name || 'file'}):`, errMsg)
           }
         }
@@ -188,44 +190,29 @@ const discord: PlatformConnector = {
       try {
         // Show typing indicator
         await message.channel.sendTyping()
-        const response = await onMessage(inbound)
-
-        if (isNoMessage(response)) return
-
-        const replyOptions = getConnectorReplySendOptions({ connectorId: connector.id, inbound })
-        const targetChannelId = replyOptions.threadId || inbound.channelId
-        const sendChunk = async (chunk: string, isFirstChunk: boolean) => {
-          const channel = await resolveTextChannel(targetChannelId)
-          const payload: Record<string, unknown> = {
-            content: chunk,
-            allowedMentions: { repliedUser: false },
-          }
-          if (isFirstChunk && replyOptions.replyToMessageId) {
-            payload.reply = {
-              messageReference: replyOptions.replyToMessageId,
-              failIfNotExists: false,
-            }
-          }
-          const sent = await channel.send(payload)
-          return String(sent.id || '')
-        }
-
-        let lastMessageId: string | undefined
-        // Discord has a 2000 char limit per message
-        if (response.length <= 2000) {
-          lastMessageId = await sendChunk(response, true)
-        } else {
-          // Split into chunks
-          const chunks = response.match(/[\s\S]{1,1990}/g) || [response]
-          for (let i = 0; i < chunks.length; i += 1) {
-            lastMessageId = await sendChunk(chunks[i], i === 0)
-          }
-        }
-        await recordConnectorOutboundDelivery({
+        const reply = await resolveConnectorIngressReply(onMessage, inbound)
+        if (!reply) return
+        await deliverChunkedConnectorText({
           connectorId: connector.id,
           inbound,
-          messageId: lastMessageId,
-          state: 'sent',
+          text: reply.visibleText,
+          maxSingleMessageLength: 2000,
+          chunkLength: 1990,
+          sendChunk: async (chunk, meta) => {
+            const channel = await resolveTextChannel(meta.threadId || inbound.channelId)
+            const payload: Record<string, unknown> = {
+              content: chunk,
+              allowedMentions: { repliedUser: false },
+            }
+            if (meta.isFirstChunk && meta.replyToMessageId) {
+              payload.reply = {
+                messageReference: meta.replyToMessageId,
+                failIfNotExists: false,
+              }
+            }
+            const sent = await channel.send(payload)
+            return String(sent.id || '')
+          },
         })
       } catch (err: any) {
         console.error(`[discord] Error handling message:`, err.message)
@@ -238,7 +225,7 @@ const discord: PlatformConnector = {
     await client.login(botToken)
     console.log(`[discord] Bot logged in as ${client.user?.tag}`)
 
-    return {
+    const instance: ConnectorInstance = {
       connector,
       isAlive() {
         return client.isReady()
@@ -300,6 +287,16 @@ const discord: PlatformConnector = {
         console.log(`[discord] Bot disconnected`)
       },
     }
+
+    // Terminal disconnect — discord.js won't auto-reconnect for these
+    client.once('invalidated', () => {
+      instance.onCrash?.('Discord session invalidated')
+    })
+    client.on('shardError', (error) => {
+      console.error(`[discord] Shard error:`, error.message)
+    })
+
+    return instance
   },
 }
 

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

@@ -3,7 +3,8 @@ import { createTransport, type Transporter } from 'nodemailer'
 import { simpleParser } from 'mailparser'
 import type { Connector } from '@/types'
 import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
-import { isNoMessage } from './manager'
+import { resolveConnectorIngressReply } from './ingress-delivery'
+import { errorMessage } from '@/lib/shared-utils'
 
 interface EmailConfig {
   imapHost: string
@@ -92,7 +93,7 @@ const email: PlatformConnector = {
         }
       } catch (err: unknown) {
         connected = false
-        const msg = err instanceof Error ? err.message : String(err)
+        const msg = errorMessage(err)
         console.error(`[email] IMAP connection failed: ${msg}`)
         throw err
       }
@@ -105,7 +106,7 @@ const email: PlatformConnector = {
       try {
         lock = await imap.getMailboxLock(folder)
       } catch (err: unknown) {
-        const msg = err instanceof Error ? err.message : String(err)
+        const msg = errorMessage(err)
         console.error(`[email] Failed to acquire mailbox lock: ${msg}`)
         connected = false
         return
@@ -125,7 +126,7 @@ const email: PlatformConnector = {
           try {
             await processMessage(msg)
           } catch (err: unknown) {
-            const errMsg = err instanceof Error ? err.message : String(err)
+            const errMsg = errorMessage(err)
             console.error(`[email] Error processing message UID ${msg.uid}: ${errMsg}`)
           }
           if (msg.uid > highwaterUid) {
@@ -133,7 +134,7 @@ const email: PlatformConnector = {
           }
         }
       } catch (err: unknown) {
-        const errMsg = err instanceof Error ? err.message : String(err)
+        const errMsg = errorMessage(err)
         // A fetch on an empty range can throw; that's normal
         if (!errMsg.includes('Nothing to fetch')) {
           console.error(`[email] Poll error: ${errMsg}`)
@@ -191,13 +192,13 @@ const email: PlatformConnector = {
       }
 
       try {
-        const response = await onMessage(inbound)
-        if (isNoMessage(response)) return
+        const reply = await resolveConnectorIngressReply(onMessage, inbound)
+        if (!reply) return
 
         // Reply via SMTP
-        await sendReply(channelId, response)
+        await sendReply(channelId, reply.visibleText)
       } catch (err: unknown) {
-        const errMsg = err instanceof Error ? err.message : String(err)
+        const errMsg = errorMessage(err)
         console.error(`[email] Error handling message from ${fromAddr}: ${errMsg}`)
       }
     }
@@ -229,7 +230,7 @@ const email: PlatformConnector = {
 
     pollTimer = setInterval(() => {
       pollForNewMessages().catch((err: unknown) => {
-        const msg = err instanceof Error ? err.message : String(err)
+        const msg = errorMessage(err)
         console.error(`[email] Poll interval error: ${msg}`)
       })
     }, pollMs)

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

@@ -1,5 +1,5 @@
 import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
-import { isNoMessage } from './manager'
+import { resolveConnectorIngressReply } from './ingress-delivery'
 
 const googlechat: PlatformConnector = {
   async start(connector, botToken, onMessage): Promise<ConnectorInstance> {
@@ -70,9 +70,9 @@ const googlechat: PlatformConnector = {
         text,
       }
 
-      const response = await onMessage(inbound)
-      if (!response || isNoMessage(response)) return {}
-      return { text: response }
+      const reply = await resolveConnectorIngressReply(onMessage, inbound)
+      if (!reply) return {}
+      return { text: reply.visibleText }
     }
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/src/lib/server/connectors/inbound-audio-transcription.ts

@@ -3,6 +3,7 @@ import path from 'node:path'
 import { decryptKey, loadCredentials, loadSettings } from '../storage'
 import { mimeFromPath } from './media'
 import type { InboundMessage, InboundMedia } from './types'
+import { errorMessage } from '@/lib/shared-utils'
 
 const PLACEHOLDER_TEXT = new Set([
   '',
@@ -252,7 +253,7 @@ export async function enrichInboundMessageWithAudioTranscript(params: {
       console.log(`[connector] Inbound audio transcribed via ${attempt.provider}: ${path.basename(localPath)}`)
       return { ...msg, text: transcript }
     } catch (err: unknown) {
-      const reason = err instanceof Error ? err.message : String(err)
+      const reason = errorMessage(err)
       console.warn(`[connector] Inbound audio transcription failed via ${attempt.provider}: ${reason}`)
     }
   }

package/src/lib/server/connectors/ingress-delivery.ts

@@ -0,0 +1,23 @@
+import { isNoMessage } from './message-sentinel'
+import { normalizeConnectorIngressResult, type ConnectorIngressResult, type ConnectorRouteResult, type InboundMessage } from './types'
+
+export interface ConnectorIngressReply {
+  routeResult: ConnectorRouteResult
+  visibleText: string
+}
+
+export async function resolveConnectorIngressReply(
+  onMessage: (msg: InboundMessage) => Promise<ConnectorIngressResult>,
+  inbound: InboundMessage,
+): Promise<ConnectorIngressReply | null> {
+  const routeResult = normalizeConnectorIngressResult(await onMessage(inbound))
+  if (routeResult.managerHandled || routeResult.delivery === 'silent') return null
+
+  const visibleText = routeResult.visibleText
+  if (!visibleText || isNoMessage(visibleText)) return null
+
+  return {
+    routeResult,
+    visibleText,
+  }
+}