@swarmclawai/swarmclaw 0.6.6 → 0.6.7

package/src/lib/server/alert-dispatch.ts

@@ -0,0 +1,64 @@
+import { loadSettings } from './storage'
+import type { AppNotification } from '@/types'
+
+/** In-memory rate limiter: dedupKey → last dispatch timestamp */
+const recentDispatches = new Map<string, number>()
+const DEDUP_WINDOW_MS = 60_000
+
+export async function dispatchAlert(notification: AppNotification): Promise<void> {
+  const settings = loadSettings()
+  const url = typeof settings.alertWebhookUrl === 'string' ? settings.alertWebhookUrl.trim() : ''
+  if (!url) return
+
+  const allowedEvents: string[] = Array.isArray(settings.alertWebhookEvents)
+    ? settings.alertWebhookEvents
+    : ['error']
+  if (!allowedEvents.includes(notification.type)) return
+
+  // Rate limit by dedupKey (or notification id as fallback)
+  const dedupKey = notification.dedupKey || notification.id
+  const now = Date.now()
+  const lastSent = recentDispatches.get(dedupKey)
+  if (lastSent && now - lastSent < DEDUP_WINDOW_MS) return
+  recentDispatches.set(dedupKey, now)
+
+  // Prune stale entries periodically
+  if (recentDispatches.size > 200) {
+    for (const [key, ts] of recentDispatches) {
+      if (now - ts > DEDUP_WINDOW_MS) recentDispatches.delete(key)
+    }
+  }
+
+  const webhookType = settings.alertWebhookType || 'custom'
+  let body: string
+
+  if (webhookType === 'discord') {
+    body = JSON.stringify({
+      content: `⚠️ **${notification.title}**${notification.message ? `\n${notification.message}` : ''}`,
+    })
+  } else if (webhookType === 'slack') {
+    body = JSON.stringify({
+      text: `⚠️ *${notification.title}*${notification.message ? `\n${notification.message}` : ''}`,
+    })
+  } else {
+    body = JSON.stringify({
+      type: notification.type,
+      title: notification.title,
+      message: notification.message || null,
+      entityType: notification.entityType || null,
+      entityId: notification.entityId || null,
+      timestamp: notification.createdAt,
+    })
+  }
+
+  try {
+    await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body,
+      signal: AbortSignal.timeout(5000),
+    })
+  } catch (err: unknown) {
+    console.warn('[alert-dispatch] Webhook delivery failed:', err instanceof Error ? err.message : String(err))
+  }
+}

package/src/lib/server/chat-execution.ts

@@ -13,7 +13,7 @@ import {
   active,
 } from './storage'
 import { getProvider } from '@/lib/providers'
-import { estimateCost } from './cost'
+import { estimateCost, checkBudget } from './cost'
 import { log } from './logger'
 import { logExecution } from './execution-log'
 import { streamAgentChat } from './stream-agent-chat'
@@ -582,6 +582,45 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     onEvent?.({ t: 'err', text: `Capability policy blocked tools for this run: ${blockedSummary}` })
   }
 
+  // --- Agent monthly budget enforcement ---
+  if (session.agentId) {
+    const agentsMap = loadAgents()
+    const agent = agentsMap[session.agentId]
+    if (agent?.monthlyBudget && agent.monthlyBudget > 0) {
+      const budgetResult = checkBudget(agent)
+      if (!budgetResult.ok) {
+        const action = agent.budgetAction || 'warn'
+        if (action === 'block') {
+          const budgetError = budgetResult.message || `Agent budget exceeded: $${budgetResult.spend.toFixed(4)} / $${budgetResult.budget.toFixed(2)}`
+          onEvent?.({ t: 'err', text: budgetError })
+
+          let persisted = false
+          if (!internal) {
+            session.messages.push({
+              role: 'assistant',
+              text: budgetError,
+              time: Date.now(),
+            })
+            session.lastActiveAt = Date.now()
+            saveSessions(sessions)
+            persisted = true
+          }
+
+          return {
+            runId,
+            sessionId,
+            text: budgetError,
+            persisted,
+            toolEvents: [],
+            error: budgetError,
+          }
+        }
+        // budgetAction === 'warn': emit a warning but continue
+        onEvent?.({ t: 'status', text: JSON.stringify({ budgetWarning: budgetResult.message }) })
+      }
+    }
+  }
+
   const dailySpendLimitUsd = parseUsdLimit(appSettings.safetyMaxDailySpendUsd)
   if (dailySpendLimitUsd !== null) {
     const todaySpendUsd = getTodaySpendUsd()
@@ -731,6 +770,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
           active,
           loadHistory: isAutoRunNoHistory ? () => getSessionMessages(sessionId).slice(-6) : (sid: string) => applyContextClearBoundary(getSessionMessages(sid)),
           onUsage: (u) => { directUsage.inputTokens = u.inputTokens; directUsage.outputTokens = u.outputTokens; directUsage.received = true },
+          signal: abortController.signal,
         })
   } catch (err: any) {
     errorMessage = err?.message || String(err)

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

@@ -1,7 +1,7 @@
 import { loadSettings, loadSkills, loadCredentials, decryptKey } from './storage'
 import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
 import { genId } from '@/lib/id'
-import type { Chatroom, Agent, Session, Message } from '@/types'
+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 {
@@ -12,6 +12,27 @@ 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 {

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