@swarmclawai/swarmclaw 0.6.4 → 0.6.7

package/src/lib/server/chatroom-health.ts

@@ -0,0 +1,60 @@
+import { getProvider } from '@/lib/providers'
+import type { Agent } from '@/types'
+import { resolveApiKey } from './chatroom-helpers'
+import { isProviderCoolingDown } from './provider-health'
+
+export interface ChatroomAgentHealthSkip {
+  agentId: string
+  reason: string
+}
+
+export interface ChatroomAgentHealthResult {
+  healthyAgentIds: string[]
+  skipped: ChatroomAgentHealthSkip[]
+}
+
+/**
+ * Filter chatroom participants to agents that are currently executable.
+ * This should never enforce model diversity rules; it only gates hard runtime blockers.
+ */
+export function filterHealthyChatroomAgents(
+  agentIds: string[],
+  agents: Record<string, Agent>,
+): ChatroomAgentHealthResult {
+  const healthyAgentIds: string[] = []
+  const skipped: ChatroomAgentHealthSkip[] = []
+
+  for (const agentId of agentIds) {
+    const agent = agents[agentId]
+    if (!agent) {
+      skipped.push({ agentId, reason: 'agent_not_found' })
+      continue
+    }
+
+    if (isProviderCoolingDown(agent.provider)) {
+      skipped.push({ agentId, reason: `provider_cooling_down:${agent.provider}` })
+      continue
+    }
+
+    const providerInfo = getProvider(agent.provider)
+    if (!providerInfo) {
+      skipped.push({ agentId, reason: `provider_not_configured:${agent.provider}` })
+      continue
+    }
+
+    const apiKey = resolveApiKey(agent.credentialId)
+    if (providerInfo.requiresApiKey && !apiKey) {
+      skipped.push({ agentId, reason: 'missing_api_credentials' })
+      continue
+    }
+    if (providerInfo.requiresEndpoint && !agent.apiEndpoint) {
+      skipped.push({ agentId, reason: 'missing_api_endpoint' })
+      continue
+    }
+
+    healthyAgentIds.push(agentId)
+  }
+
+  return { healthyAgentIds, skipped }
+}
+

package/src/lib/server/chatroom-helpers.test.ts

@@ -0,0 +1,94 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import type { Agent, Chatroom } from '@/types'
+import { parseMentions, compactChatroomMessages, buildHistoryForAgent } from './chatroom-helpers'
+
+function makeAgents(): Record<string, Agent> {
+  const now = Date.now()
+  return {
+    default: {
+      id: 'default',
+      name: 'Assistant',
+      description: '',
+      systemPrompt: '',
+      provider: 'openai',
+      model: 'gpt-4o',
+      createdAt: now,
+      updatedAt: now,
+    },
+    agent_analyst: {
+      id: 'agent_analyst',
+      name: 'Analyst',
+      description: '',
+      systemPrompt: '',
+      provider: 'openai',
+      model: 'gpt-4o',
+      createdAt: now,
+      updatedAt: now,
+    },
+  }
+}
+
+describe('chatroom-helpers', () => {
+  it('parses mentions with punctuation and agent ids', () => {
+    const agents = makeAgents()
+    const memberIds = ['default', 'agent_analyst']
+    const mentions = parseMentions('Hey @Assistant, can @agent_analyst review this?', agents, memberIds)
+    assert.deepEqual(mentions, ['default', 'agent_analyst'])
+  })
+
+  it('compacts long chatrooms with a persisted summary message', () => {
+    const now = Date.now()
+    const chatroom: Chatroom = {
+      id: 'room-1',
+      name: 'Room',
+      description: '',
+      agentIds: ['default'],
+      messages: Array.from({ length: 120 }, (_, idx) => ({
+        id: `m-${idx}`,
+        senderId: idx % 2 === 0 ? 'user' : 'default',
+        senderName: idx % 2 === 0 ? 'You' : 'Assistant',
+        role: idx % 2 === 0 ? 'user' : 'assistant',
+        text: `message ${idx}`,
+        mentions: [],
+        reactions: [],
+        time: now + idx,
+      })),
+      createdAt: now,
+      updatedAt: now,
+    }
+
+    const changed = compactChatroomMessages(chatroom, 90)
+    assert.equal(changed, true)
+    assert.equal(chatroom.messages.length, 91)
+    assert.equal(chatroom.messages[0].senderId, 'system')
+    assert.match(chatroom.messages[0].text, /^\[Conversation summary\]/)
+  })
+
+  it('only includes attachment-heavy context for recent history entries', () => {
+    const now = Date.now()
+    const chatroom: Chatroom = {
+      id: 'room-2',
+      name: 'Room',
+      agentIds: ['default'],
+      messages: Array.from({ length: 24 }, (_, idx) => ({
+        id: `x-${idx}`,
+        senderId: idx % 2 === 0 ? 'user' : 'default',
+        senderName: idx % 2 === 0 ? 'You' : 'Assistant',
+        role: idx % 2 === 0 ? 'user' : 'assistant',
+        text: `line ${idx}`,
+        mentions: [],
+        reactions: [],
+        time: now + idx,
+        ...(idx < 10 ? { attachedFiles: [`/tmp/file-${idx}.txt`] } : {}),
+      })),
+      createdAt: now,
+      updatedAt: now,
+    }
+
+    const history = buildHistoryForAgent(chatroom, 'default')
+    const attachmentMarkers = history.filter((msg) => msg.text.includes('[Attached:')).length
+    assert.ok(attachmentMarkers <= 6)
+  })
+})
+

package/src/lib/server/chatroom-helpers.ts

@@ -1,6 +1,7 @@
 import { loadSettings, loadSkills, loadCredentials, decryptKey } from './storage'
 import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
-import type { Chatroom, Agent, Session, Message } from '@/types'
+import { genId } from '@/lib/id'
+import type { Chatroom, ChatroomMember, Agent, Session, Message } from '@/types'
 
 /** Resolve API key from an agent's credentialId */
 export function resolveApiKey(credentialId: string | null | undefined): string | null {
@@ -11,17 +12,57 @@ export function resolveApiKey(credentialId: string | null | undefined): string |
   try { return decryptKey(cred.encryptedKey) } catch { return null }
 }
 
+/** Derive chatroom members from the `members` array if present, otherwise fallback to `agentIds` with default 'member' role. */
+export function getMembers(chatroom: Chatroom): ChatroomMember[] {
+  if (chatroom.members?.length) return chatroom.members
+  return chatroom.agentIds.map((agentId) => ({ agentId, role: 'member' as const }))
+}
+
+/** Return the role of an agent in a chatroom, defaulting to 'member'. */
+export function getMemberRole(chatroom: Chatroom, agentId: string): string {
+  const members = getMembers(chatroom)
+  const member = members.find((m) => m.agentId === agentId)
+  return member?.role || 'member'
+}
+
+/** Check if an agent is currently muted in the chatroom. */
+export function isMuted(chatroom: Chatroom, agentId: string): boolean {
+  const members = getMembers(chatroom)
+  const member = members.find((m) => m.agentId === agentId)
+  if (!member?.mutedUntil) return false
+  return new Date(member.mutedUntil).getTime() > Date.now()
+}
+
+const COMPACTION_PREFIX = '[Conversation summary]'
+
+function normalizeMentionToken(raw: string): string {
+  return raw
+    .toLowerCase()
+    .replace(/[.,!?;:]+$/g, '')
+    .replace(/\s+/g, '')
+    .trim()
+}
+
+function truncateText(text: string, max: number): string {
+  const compact = String(text || '').replace(/\s+/g, ' ').trim()
+  if (compact.length <= max) return compact
+  return `${compact.slice(0, Math.max(0, max - 3))}...`
+}
+
 /** Parse @mentions from message text, returns matching agentIds */
 export function parseMentions(text: string, agents: Record<string, Agent>, memberIds: string[]): string[] {
   if (/@all\b/i.test(text)) return [...memberIds]
-  const mentionPattern = /@(\S+)/g
+  const mentionPattern = /(?:^|[\s(])@([a-zA-Z0-9._-]+)/g
   const mentioned: string[] = []
   let match: RegExpExecArray | null
   while ((match = mentionPattern.exec(text)) !== null) {
-    const name = match[1].toLowerCase()
+    const token = normalizeMentionToken(match[1] || '')
+    if (!token) continue
     for (const id of memberIds) {
       const agent = agents[id]
-      if (agent && agent.name.toLowerCase().replace(/\s+/g, '') === name) {
+      const normalizedName = normalizeMentionToken(agent?.name || '')
+      const normalizedId = normalizeMentionToken(id)
+      if (agent && (normalizedName === token || normalizedId === token)) {
         if (!mentioned.includes(id)) mentioned.push(id)
       }
     }
@@ -29,6 +70,34 @@ export function parseMentions(text: string, agents: Record<string, Agent>, membe
   return mentioned
 }
 
+/**
+ * Persisted chatroom compaction so long-lived rooms stay inside context budgets.
+ * Returns true when the message list was compacted.
+ */
+export function compactChatroomMessages(chatroom: Chatroom, keepLast = 90): boolean {
+  const maxKeep = Math.max(20, keepLast)
+  if (!Array.isArray(chatroom.messages) || chatroom.messages.length <= maxKeep) return false
+
+  const dropped = chatroom.messages.length - maxKeep
+  const kept = chatroom.messages.slice(-maxKeep).filter((msg, idx) => {
+    if (idx !== 0) return true
+    return !(msg.senderId === 'system' && typeof msg.text === 'string' && msg.text.startsWith(COMPACTION_PREFIX))
+  })
+  const summaryMessage = {
+    id: genId(),
+    senderId: 'system',
+    senderName: 'System',
+    role: 'assistant' as const,
+    text: `${COMPACTION_PREFIX} ${dropped} earlier chat message(s) were condensed to keep the room responsive.`,
+    mentions: [],
+    reactions: [],
+    time: Date.now(),
+  }
+  chatroom.messages = [summaryMessage, ...kept]
+  chatroom.updatedAt = Date.now()
+  return true
+}
+
 /** Build chatroom context as a system prompt addendum with agent profiles and collaboration guidelines */
 export function buildChatroomSystemPrompt(chatroom: Chatroom, agents: Record<string, Agent>, agentId: string): string {
   const selfAgent = agents[agentId]
@@ -47,9 +116,10 @@ export function buildChatroomSystemPrompt(chatroom: Chatroom, agents: Record<str
     .filter(Boolean)
     .join('\n')
 
-  const recentMessages = chatroom.messages.slice(-30).map((m) => {
-    return `[${m.senderName}]: ${m.text}`
-  }).join('\n')
+  const recentMessages = chatroom.messages
+    .slice(-8)
+    .map((m) => `[${m.senderName}]: ${truncateText(m.text, 180)}`)
+    .join('\n')
 
   const memberCount = chatroom.agentIds.length
   const otherNames = chatroom.agentIds
@@ -70,6 +140,8 @@ export function buildChatroomSystemPrompt(chatroom: Chatroom, agents: Record<str
     '- **You are in a group chat.** Talk like you are in a real-time conversation with teammates — be direct, casual, and concise.',
     '- **Be yourself.** Respond with personality. Don\'t give generic "let me know if you need anything" responses. Actually engage with what was said.',
     '- **Answer the question or react to the message.** If someone says "how are you doing?" just answer naturally. If someone asks a question you can help with, help directly.',
+    '- **Do not meta-narrate user intent.** Avoid phrases like "it seems like you\'re trying to..." — respond directly to what they said.',
+    '- **Handle greetings like a human.** For "hello", "how are you", or light check-ins, give a normal conversational reply instead of tool/process commentary.',
     '- **Keep responses short** unless depth is needed. A few sentences is usually enough. This is a chat, not an essay.',
     '- **@mention teammates** only when you genuinely need their specific expertise. Don\'t tag people just to be polite.',
     '- **Don\'t narrate your capabilities** unless asked. Just demonstrate them by doing things.',
@@ -121,10 +193,12 @@ export function buildAgentSystemPromptForChatroom(agent: Agent): string {
 
 /** Convert chatroom messages to Message history format for LLM */
 export function buildHistoryForAgent(chatroom: Chatroom, agentId: string, imagePath?: string, attachedFiles?: string[]): Message[] {
-  const history = chatroom.messages.slice(-50).map((m) => {
+  const recentMessages = chatroom.messages.slice(-24)
+  const includeAttachmentsFrom = Math.max(0, recentMessages.length - 6)
+  const history = recentMessages.map((m, idx) => {
     let msgText = `[${m.senderName}]: ${m.text}`
-    // Include attachment info in history
-    if (m.attachedFiles?.length) {
+    const includeAttachments = idx >= includeAttachmentsFrom
+    if (includeAttachments && m.attachedFiles?.length) {
       const names = m.attachedFiles.map((f) => f.split('/').pop()).join(', ')
       msgText += `\n[Attached: ${names}]`
     }
@@ -132,8 +206,8 @@ export function buildHistoryForAgent(chatroom: Chatroom, agentId: string, imageP
       role: m.senderId === agentId ? 'assistant' as const : 'user' as const,
       text: msgText,
       time: m.time,
-      ...(m.imagePath ? { imagePath: m.imagePath } : {}),
-      ...(m.attachedFiles ? { attachedFiles: m.attachedFiles } : {}),
+      ...(includeAttachments && m.imagePath ? { imagePath: m.imagePath } : {}),
+      ...(includeAttachments && m.attachedFiles ? { attachedFiles: m.attachedFiles } : {}),
     }
   })
   // Pass through imagePath/attachedFiles from the current message to the last history entry

package/src/lib/server/chatroom-routing.ts

@@ -0,0 +1,65 @@
+import type { ChatroomRoutingRule, Agent } from '@/types'
+
+/**
+ * Evaluate routing rules against inbound message text.
+ *
+ * Rules are evaluated in priority order (lower number = higher priority).
+ * First match wins — returns the matched agentIds.
+ *
+ * - 'keyword' rules: case-insensitive substring match against `keywords[]`,
+ *   or regex match against `pattern`.
+ * - 'capability' rules: match `pattern` against each agent's `capabilities[]`.
+ */
+export function evaluateRoutingRules(
+  text: string,
+  rules: ChatroomRoutingRule[],
+  agents: Agent[],
+): string[] {
+  if (!rules.length) return []
+
+  const sorted = [...rules].sort((a, b) => a.priority - b.priority)
+  const lowerText = text.toLowerCase()
+
+  for (const rule of sorted) {
+    if (rule.type === 'keyword') {
+      let matched = false
+
+      // Check keywords (case-insensitive substring)
+      if (rule.keywords?.length) {
+        matched = rule.keywords.some((kw) => lowerText.includes(kw.toLowerCase()))
+      }
+
+      // Check pattern (regex)
+      if (!matched && rule.pattern) {
+        try {
+          const re = new RegExp(rule.pattern, 'i')
+          matched = re.test(text)
+        } catch {
+          // Invalid regex — skip
+        }
+      }
+
+      if (matched) return [rule.agentId]
+    }
+
+    if (rule.type === 'capability') {
+      if (!rule.pattern) continue
+      const patternLower = rule.pattern.toLowerCase()
+
+      // Check if the specific agent has a matching capability
+      const agent = agents.find((a) => a.id === rule.agentId)
+      if (agent?.capabilities?.some((cap) => cap.toLowerCase().includes(patternLower))) {
+        // Only match if the message text is relevant to the capability
+        // Use the pattern as a keyword match against the message text too
+        try {
+          const re = new RegExp(rule.pattern, 'i')
+          if (re.test(text)) return [rule.agentId]
+        } catch {
+          if (lowerText.includes(patternLower)) return [rule.agentId]
+        }
+      }
+    }
+  }
+
+  return []
+}

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

@@ -105,6 +105,9 @@ const discord: PlatformConnector = {
 
     return {
       connector,
+      isAlive() {
+        return client.isReady()
+      },
       async sendMessage(channelId, text, options) {
         const channel = await client.channels.fetch(channelId)
         if (!channel || !('send' in channel) || typeof (channel as any).send !== 'function') {

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

@@ -0,0 +1,267 @@
+import { ImapFlow } from 'imapflow'
+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'
+
+interface EmailConfig {
+  imapHost: string
+  imapPort?: number
+  smtpHost: string
+  smtpPort?: number
+  user: string
+  password: string
+  folder?: string
+  pollIntervalSec?: number
+  subjectPrefix?: string
+}
+
+function getConfig(connector: Connector): EmailConfig {
+  const c = connector.config as Record<string, unknown>
+  return {
+    imapHost: String(c.imapHost ?? ''),
+    imapPort: Number(c.imapPort ?? 993),
+    smtpHost: String(c.smtpHost ?? ''),
+    smtpPort: Number(c.smtpPort ?? 587),
+    user: String(c.user ?? ''),
+    password: String(c.password ?? ''),
+    folder: String(c.folder ?? 'INBOX'),
+    pollIntervalSec: Number(c.pollIntervalSec ?? 60),
+    subjectPrefix: c.subjectPrefix ? String(c.subjectPrefix) : undefined,
+  }
+}
+
+const email: PlatformConnector = {
+  async start(connector, _botToken, onMessage): Promise<ConnectorInstance> {
+    const config = getConfig(connector)
+
+    if (!config.imapHost || !config.smtpHost || !config.user || !config.password) {
+      throw new Error('Email connector requires imapHost, smtpHost, user, and password')
+    }
+
+    const folder = config.folder || 'INBOX'
+    const pollMs = (config.pollIntervalSec || 60) * 1000
+
+    // IMAP client for inbound
+    const imap = new ImapFlow({
+      host: config.imapHost,
+      port: config.imapPort || 993,
+      secure: (config.imapPort || 993) === 993,
+      auth: {
+        user: config.user,
+        pass: config.password,
+      },
+      logger: false,
+    })
+
+    // SMTP transport for outbound
+    const smtp: Transporter = createTransport({
+      host: config.smtpHost,
+      port: config.smtpPort || 587,
+      secure: (config.smtpPort || 587) === 465,
+      auth: {
+        user: config.user,
+        pass: config.password,
+      },
+    })
+
+    // Track last seen UID to only process new messages
+    let highwaterUid = 0
+    let connected = false
+    let pollTimer: ReturnType<typeof setInterval> | null = null
+
+    // Map to track original sender per channelId (email address) for replies
+    const senderMap = new Map<string, { address: string; subject: string; messageId?: string }>()
+
+    async function connectImap(): Promise<void> {
+      try {
+        await imap.connect()
+        connected = true
+        console.log(`[email] IMAP connected to ${config.imapHost}`)
+
+        // Get the current highest UID as highwater mark (don't process old messages)
+        const lock = await imap.getMailboxLock(folder)
+        try {
+          const status = await imap.status(folder, { uidNext: true })
+          // uidNext is the next UID that will be assigned; current highest is uidNext - 1
+          highwaterUid = typeof status.uidNext === 'number' ? status.uidNext - 1 : 0
+          console.log(`[email] Initial highwater UID: ${highwaterUid} in ${folder}`)
+        } finally {
+          lock.release()
+        }
+      } catch (err: unknown) {
+        connected = false
+        const msg = err instanceof Error ? err.message : String(err)
+        console.error(`[email] IMAP connection failed: ${msg}`)
+        throw err
+      }
+    }
+
+    async function pollForNewMessages(): Promise<void> {
+      if (!connected) return
+
+      let lock
+      try {
+        lock = await imap.getMailboxLock(folder)
+      } catch (err: unknown) {
+        const msg = err instanceof Error ? err.message : String(err)
+        console.error(`[email] Failed to acquire mailbox lock: ${msg}`)
+        connected = false
+        return
+      }
+
+      try {
+        // Fetch messages with UID > highwaterUid
+        const range = `${highwaterUid + 1}:*`
+        const messages = []
+
+        for await (const msg of imap.fetch(range, { envelope: true, source: true, uid: true }, { uid: true })) {
+          if (msg.uid <= highwaterUid) continue
+          messages.push(msg)
+        }
+
+        for (const msg of messages) {
+          try {
+            await processMessage(msg)
+          } catch (err: unknown) {
+            const errMsg = err instanceof Error ? err.message : String(err)
+            console.error(`[email] Error processing message UID ${msg.uid}: ${errMsg}`)
+          }
+          if (msg.uid > highwaterUid) {
+            highwaterUid = msg.uid
+          }
+        }
+      } catch (err: unknown) {
+        const errMsg = err instanceof Error ? err.message : String(err)
+        // A fetch on an empty range can throw; that's normal
+        if (!errMsg.includes('Nothing to fetch')) {
+          console.error(`[email] Poll error: ${errMsg}`)
+        }
+      } finally {
+        lock.release()
+      }
+    }
+
+    async function processMessage(msg: { uid: number; envelope?: { from?: Array<{ name?: string; address?: string }>; subject?: string; messageId?: string }; source?: Buffer }): Promise<void> {
+      const envelope = msg.envelope
+      if (!envelope) return
+
+      const fromAddr = envelope.from?.[0]?.address || 'unknown'
+      const fromName = envelope.from?.[0]?.name || fromAddr
+      const subject = envelope.subject || '(no subject)'
+
+      // Filter by subject prefix if configured
+      if (config.subjectPrefix && !subject.startsWith(config.subjectPrefix)) {
+        console.log(`[email] Skipping message from ${fromAddr} — subject "${subject}" doesn't match prefix "${config.subjectPrefix}"`)
+        return
+      }
+
+      // Parse the email body for text content
+      let bodyText = ''
+      if (msg.source) {
+        const parsed = await simpleParser(msg.source)
+        bodyText = parsed.text || ''
+      }
+
+      if (!bodyText.trim()) {
+        console.log(`[email] Skipping empty message from ${fromAddr}`)
+        return
+      }
+
+      console.log(`[email] New message from ${fromName} <${fromAddr}>: ${subject}`)
+
+      // Use the sender's email as channelId
+      const channelId = fromAddr
+
+      // Store sender info for replies
+      senderMap.set(channelId, {
+        address: fromAddr,
+        subject,
+        messageId: envelope.messageId,
+      })
+
+      const inbound: InboundMessage = {
+        platform: 'email',
+        channelId,
+        channelName: `Email: ${fromName}`,
+        senderId: fromAddr,
+        senderName: fromName,
+        text: bodyText.trim(),
+      }
+
+      try {
+        const response = await onMessage(inbound)
+        if (isNoMessage(response)) return
+
+        // Reply via SMTP
+        await sendReply(channelId, response)
+      } catch (err: unknown) {
+        const errMsg = err instanceof Error ? err.message : String(err)
+        console.error(`[email] Error handling message from ${fromAddr}: ${errMsg}`)
+      }
+    }
+
+    async function sendReply(channelId: string, text: string): Promise<void> {
+      const sender = senderMap.get(channelId)
+      const to = sender?.address || channelId
+      const subject = sender?.subject ? `Re: ${sender.subject.replace(/^Re:\s*/i, '')}` : 'Re: SwarmClaw'
+
+      const mailOptions: Record<string, unknown> = {
+        from: config.user,
+        to,
+        subject,
+        text,
+      }
+
+      // Thread the reply using In-Reply-To header
+      if (sender?.messageId) {
+        mailOptions['inReplyTo'] = sender.messageId
+        mailOptions['references'] = sender.messageId
+      }
+
+      await smtp.sendMail(mailOptions)
+      console.log(`[email] Reply sent to ${to}`)
+    }
+
+    // Connect and start polling
+    await connectImap()
+
+    pollTimer = setInterval(() => {
+      pollForNewMessages().catch((err: unknown) => {
+        const msg = err instanceof Error ? err.message : String(err)
+        console.error(`[email] Poll interval error: ${msg}`)
+      })
+    }, pollMs)
+
+    console.log(`[email] Connector started — polling every ${config.pollIntervalSec || 60}s`)
+
+    return {
+      connector,
+
+      isAlive() {
+        return connected && imap.usable
+      },
+
+      async sendMessage(channelId, text) {
+        await sendReply(channelId, text)
+      },
+
+      async stop() {
+        if (pollTimer) {
+          clearInterval(pollTimer)
+          pollTimer = null
+        }
+        try {
+          await imap.logout()
+        } catch {
+          // Connection may already be closed
+        }
+        connected = false
+        console.log(`[email] Connector stopped`)
+      },
+    }
+  },
+}
+
+export default email