@swarmclawai/swarmclaw 1.5.53 → 1.5.55

package/src/lib/server/chatrooms/chatroom-agent-signals.ts

@@ -1,7 +1,84 @@
+import { z } from 'zod'
 import type { Chatroom, Agent } from '@/types'
 import { patchChatroom } from '@/lib/server/chatrooms/chatroom-repository'
 import { notify } from '@/lib/server/ws-hub'
 
+const REACTION_MARKER = '[REACTION]'
+
+const ReactionPayloadSchema = z.object({
+  emoji: z.string().min(1),
+  to: z.string().min(1),
+}).passthrough()
+type ReactionPayload = z.infer<typeof ReactionPayloadSchema>
+
+interface ReactionMatch {
+  start: number
+  end: number
+  payload: ReactionPayload
+}
+
+function findBalancedJsonObjectEnd(text: string, start: number): number {
+  if (text.charAt(start) !== '{') return -1
+  let depth = 0
+  let inString = false
+  let escaped = false
+  for (let i = start; i < text.length; i += 1) {
+    const c = text.charAt(i)
+    if (inString) {
+      if (escaped) escaped = false
+      else if (c === '\\') escaped = true
+      else if (c === '"') inString = false
+      continue
+    }
+    if (c === '"') {
+      inString = true
+      continue
+    }
+    if (c === '{') depth += 1
+    else if (c === '}') {
+      depth -= 1
+      if (depth === 0) return i + 1
+    }
+  }
+  return -1
+}
+
+function findReactionMatches(text: string): ReactionMatch[] {
+  const matches: ReactionMatch[] = []
+  if (!text) return matches
+  let cursor = 0
+  while (cursor < text.length) {
+    const markerAt = text.indexOf(REACTION_MARKER, cursor)
+    if (markerAt < 0) break
+    let jsonStart = markerAt + REACTION_MARKER.length
+    while (jsonStart < text.length && /\s/.test(text.charAt(jsonStart))) jsonStart += 1
+    if (text.charAt(jsonStart) !== '{') {
+      cursor = markerAt + REACTION_MARKER.length
+      continue
+    }
+    const jsonEnd = findBalancedJsonObjectEnd(text, jsonStart)
+    if (jsonEnd <= jsonStart) {
+      cursor = markerAt + REACTION_MARKER.length
+      continue
+    }
+    let parsed: unknown
+    try {
+      parsed = JSON.parse(text.slice(jsonStart, jsonEnd))
+    } catch {
+      cursor = jsonStart + 1
+      continue
+    }
+    const validated = ReactionPayloadSchema.safeParse(parsed)
+    if (!validated.success) {
+      cursor = jsonEnd
+      continue
+    }
+    matches.push({ start: markerAt, end: jsonEnd, payload: validated.data })
+    cursor = jsonEnd
+  }
+  return matches
+}
+
 /**
  * Normalizes text for comparison (lowercase, alphanumeric only)
  */
@@ -67,16 +144,35 @@ export function addAgentReaction(chatroomId: string, messageId: string, agentId:
 /**
  * Parses [REACTION] tokens from agent output and applies them.
  * Format: [REACTION]{"emoji": "👍", "to": "msg_id"}
+ *
+ * Uses a balanced-brace walker + zod validation so nested JSON or noisy
+ * payloads don't slip past, and so unrelated `[REACTION]something` text
+ * doesn't get spuriously consumed.
  */
 export function applyAgentReactionsFromText(text: string, chatroomId: string, agentId: string) {
-  const reactionRegex = /\[REACTION\]\s*(\{.*?\})/g
-  let match
-  while ((match = reactionRegex.exec(text)) !== null) {
-    try {
-      const data = JSON.parse(match[1])
-      if (data.emoji && data.to) {
-        addAgentReaction(chatroomId, data.to, agentId, data.emoji)
-      }
-    } catch { /* ignore invalid JSON */ }
+  for (const match of findReactionMatches(text)) {
+    addAgentReaction(chatroomId, match.payload.to, agentId, match.payload.emoji)
+  }
+}
+
+/**
+ * Removes [REACTION]{...} markers from agent output so they don't bleed into
+ * the visible message body. Reactions are persisted separately by
+ * applyAgentReactionsFromText.
+ */
+export function stripAgentReactionTokens(text: string): string {
+  if (!text) return text
+  const matches = findReactionMatches(text)
+  if (matches.length === 0) return text
+  let out = ''
+  let cursor = 0
+  for (const match of matches) {
+    out += text.slice(cursor, match.start)
+    cursor = match.end
   }
+  out += text.slice(cursor)
+  return out
+    .replace(/[ \t]+\n/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim()
 }

package/src/lib/server/chats/chat-session-service.ts

@@ -7,6 +7,7 @@ import { buildAgentDisabledMessage, isAgentDisabled } from '@/lib/server/agents/
 import { loadAgent } from '@/lib/server/agents/agent-repository'
 import { clearMainLoopStateForSession } from '@/lib/server/agents/main-agent-loop'
 import { applyResolvedRoute, resolvePrimaryAgentRoute } from '@/lib/server/agents/agent-runtime-config'
+import { loadCredentials } from '@/lib/server/credentials/credential-repository'
 import { cleanupSessionProcesses } from '@/lib/server/runtime/process-manager'
 import { stopActiveSessionProcess } from '@/lib/server/runtime/runtime-state'
 import {
@@ -235,6 +236,13 @@ export function updateChatSession(sessionId: string, updates: Record<string, unk
   if (updates.credentialId !== undefined) session.credentialId = updates.credentialId
   else if (agentIdUpdateProvided && linkedRoute) session.credentialId = linkedRoute.credentialId ?? null
   else if (agentIdUpdateProvided && linkedAgent) session.credentialId = linkedAgent.credentialId ?? null
+  else if (updates.provider !== undefined && updates.provider !== session.provider) {
+    // Provider changed without an explicit credentialId — find a stored credential
+    // for the new provider so API-key-based providers (Groq, OpenAI, …) work.
+    const allCreds = loadCredentials()
+    const providerCred = Object.values(allCreds).find(c => c.provider === updates.provider)
+    session.credentialId = providerCred?.id ?? null
+  }
   if (updates.fallbackCredentialIds !== undefined) session.fallbackCredentialIds = updates.fallbackCredentialIds
   else if (agentIdUpdateProvided && linkedRoute) session.fallbackCredentialIds = [...linkedRoute.fallbackCredentialIds]
   if (updates.gatewayProfileId !== undefined) session.gatewayProfileId = updates.gatewayProfileId
@@ -264,6 +272,9 @@ export function updateChatSession(sessionId: string, updates: Record<string, unk
     session.apiEndpoint = linkedRoute.apiEndpoint ?? null
   } else if (agentIdUpdateProvided && linkedAgent) {
     session.apiEndpoint = normalizeProviderEndpoint(linkedAgent.provider, linkedAgent.apiEndpoint ?? null)
+  } else if (updates.provider !== undefined && updates.provider !== session.provider) {
+    // Provider changed — clear stale endpoint so the new provider uses its own default.
+    session.apiEndpoint = null
   }
   if (updates.heartbeatEnabled !== undefined) session.heartbeatEnabled = updates.heartbeatEnabled
   if (updates.heartbeatIntervalSec !== undefined) session.heartbeatIntervalSec = updates.heartbeatIntervalSec

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

@@ -0,0 +1,64 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { describe, it } from 'node:test'
+import { buildAttachments } from './email'
+import { connectorSupportsBinaryMedia } from './response-media'
+
+describe('connectorSupportsBinaryMedia — email', () => {
+  it('marks email as supporting outbound binary media', () => {
+    assert.equal(connectorSupportsBinaryMedia('email'), true)
+  })
+
+  it('still returns false for platforms that do not support outbound binary', () => {
+    assert.equal(connectorSupportsBinaryMedia('signal'), false)
+    assert.equal(connectorSupportsBinaryMedia('matrix'), false)
+  })
+})
+
+describe('email buildAttachments', () => {
+  it('returns an empty array when no mediaPath is set', () => {
+    assert.deepEqual(buildAttachments(), [])
+    assert.deepEqual(buildAttachments({}), [])
+  })
+
+  it('returns an empty array when mediaPath points at a missing file', () => {
+    const missing = path.join(os.tmpdir(), `swarmclaw-email-missing-${Date.now()}.bin`)
+    assert.equal(fs.existsSync(missing), false)
+    assert.deepEqual(buildAttachments({ mediaPath: missing }), [])
+  })
+
+  it('builds a single attachment entry from mediaPath, defaulting the filename to basename', () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-email-test-'))
+    const file = path.join(dir, 'report.pdf')
+    fs.writeFileSync(file, '%PDF-1.4 test')
+    try {
+      const attachments = buildAttachments({ mediaPath: file })
+      assert.equal(attachments.length, 1)
+      assert.equal(attachments[0].path, file)
+      assert.equal(attachments[0].filename, 'report.pdf')
+      assert.equal(attachments[0].contentType, undefined)
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  it('respects explicit fileName and mimeType when provided', () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-email-test-'))
+    const file = path.join(dir, 'raw.bin')
+    fs.writeFileSync(file, 'x')
+    try {
+      const attachments = buildAttachments({
+        mediaPath: file,
+        fileName: 'quarterly-report.pdf',
+        mimeType: 'application/pdf',
+      })
+      assert.equal(attachments.length, 1)
+      assert.equal(attachments[0].filename, 'quarterly-report.pdf')
+      assert.equal(attachments[0].contentType, 'application/pdf')
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true })
+    }
+  })
+})

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

@@ -1,8 +1,10 @@
+import fs from 'fs'
+import path from 'path'
 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 type { PlatformConnector, ConnectorInstance, InboundMessage, OutboundSendOptions } from './types'
 import { resolveConnectorIngressReply } from './ingress-delivery'
 import { errorMessage } from '@/lib/shared-utils'
 import { log } from '@/lib/server/logger'
@@ -21,6 +23,26 @@ interface EmailConfig {
   subjectPrefix?: string
 }
 
+interface MailAttachment {
+  path: string
+  filename: string
+  contentType?: string
+}
+
+export function buildAttachments(options?: OutboundSendOptions): MailAttachment[] {
+  const source = options?.mediaPath
+  if (!source) return []
+  if (!fs.existsSync(source)) {
+    log.warn(TAG, `Attachment file not found: ${source}`)
+    return []
+  }
+  return [{
+    path: source,
+    filename: options?.fileName || path.basename(source),
+    ...(options?.mimeType ? { contentType: options.mimeType } : {}),
+  }]
+}
+
 function getConfig(connector: Connector): EmailConfig {
   const c = connector.config as Record<string, unknown>
   return {
@@ -206,7 +228,11 @@ const email: PlatformConnector = {
       }
     }
 
-    async function sendReply(channelId: string, text: string): Promise<void> {
+    async function sendReply(
+      channelId: string,
+      text: string,
+      options?: OutboundSendOptions,
+    ): 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'
@@ -215,7 +241,7 @@ const email: PlatformConnector = {
         from: config.user,
         to,
         subject,
-        text,
+        text: options?.caption || text,
       }
 
       // Thread the reply using In-Reply-To header
@@ -224,8 +250,11 @@ const email: PlatformConnector = {
         mailOptions['references'] = sender.messageId
       }
 
+      const attachments = buildAttachments(options)
+      if (attachments.length > 0) mailOptions['attachments'] = attachments
+
       await smtp.sendMail(mailOptions)
-      log.info(TAG, `Reply sent to ${to}`)
+      log.info(TAG, `Reply sent to ${to}${attachments.length ? ` with ${attachments.length} attachment(s)` : ''}`)
     }
 
     // Connect and start polling
@@ -247,8 +276,8 @@ const email: PlatformConnector = {
         return connected && imap.usable
       },
 
-      async sendMessage(channelId, text) {
-        await sendReply(channelId, text)
+      async sendMessage(channelId, text, options) {
+        await sendReply(channelId, text, options)
       },
 
       async stop() {

package/src/lib/server/connectors/response-media.ts

@@ -226,6 +226,7 @@ export function connectorSupportsBinaryMedia(platform: string): boolean {
     || platform === 'slack'
     || platform === 'discord'
     || platform === 'openclaw'
+    || platform === 'email'
 }
 
 export function formatMediaLine(media: InboundMedia): string {

package/src/lib/server/daemon/daemon-runtime.ts

@@ -319,33 +319,45 @@ async function main(): Promise<void> {
     })
   }
   process.on('uncaughtException', (err: Error) => {
-    patchDaemonStatusRecord((current) => ({
-      ...current,
-      lastError: err.message,
-      updatedAt: Date.now(),
-    }))
+    try {
+      patchDaemonStatusRecord((current) => ({
+        ...current,
+        lastError: err.message,
+        updatedAt: Date.now(),
+      }))
+    } catch (patchErr) {
+      log.error(TAG, 'Failed to record uncaughtException in daemon status', patchErr)
+    }
     void shutdown('uncaughtException').finally(() => process.exit(1))
   })
   process.on('unhandledRejection', (reason: unknown) => {
-    patchDaemonStatusRecord((current) => ({
-      ...current,
-      lastError: reason instanceof Error ? reason.message : String(reason),
-      updatedAt: Date.now(),
-    }))
+    try {
+      patchDaemonStatusRecord((current) => ({
+        ...current,
+        lastError: reason instanceof Error ? reason.message : String(reason),
+        updatedAt: Date.now(),
+      }))
+    } catch (patchErr) {
+      log.error(TAG, 'Failed to record unhandledRejection in daemon status', patchErr)
+    }
     void shutdown('unhandledRejection').finally(() => process.exit(1))
   })
 }
 
 void main().catch((err: unknown) => {
-  patchDaemonStatusRecord((current) => ({
-    ...current,
-    pid: null,
-    adminPort: null,
-    desiredState: 'stopped',
-    stoppedAt: Date.now(),
-    updatedAt: Date.now(),
-    lastError: err instanceof Error ? err.message : 'Daemon runtime failed to start',
-  }))
+  try {
+    patchDaemonStatusRecord((current) => ({
+      ...current,
+      pid: null,
+      adminPort: null,
+      desiredState: 'stopped',
+      stoppedAt: Date.now(),
+      updatedAt: Date.now(),
+      lastError: err instanceof Error ? err.message : 'Daemon runtime failed to start',
+    }))
+  } catch (patchErr) {
+    log.error(TAG, 'Failed to record fatal daemon error in status', patchErr)
+  }
   clearDaemonAdminMetadata()
   log.error(TAG, 'Fatal daemon runtime error', err)
   process.exit(1)

package/src/lib/server/memory/memory-db.test.ts

@@ -214,6 +214,14 @@ describe('memory-db', () => {
       // All terms are <3 chars or stop words
       assert.equal(query, '')
     })
+
+    it('returns a single-term FTS query for short (3-4 char) words', () => {
+      // Single words like "cats", "blue", "dog" must produce a non-empty FTS
+      // query so the memory lookup UI works for short meaningful terms.
+      assert.equal(memDb.buildFtsQuery('cats'), '"cats"')
+      assert.equal(memDb.buildFtsQuery('blue'), '"blue"')
+      assert.equal(memDb.buildFtsQuery('dog'), '"dog"')
+    })
   })
 
   // --- Content hash dedup ---

package/src/lib/server/memory/memory-db.ts

@@ -388,7 +388,7 @@ export function buildFtsQuery(input: string): string {
   }
 
   if (unique.length === 1) {
-    return unique[0].length >= 5 ? `"${unique[0].replace(/"/g, '')}"` : ''
+    return `"${unique[0].replace(/"/g, '')}"`
   }
 
   const selected = unique.slice(0, Math.min(4, MAX_FTS_QUERY_TERMS))

package/src/lib/server/missions/mission-service.ts

@@ -1,5 +1,5 @@
 import crypto from 'crypto'
-import type { Mission, MissionBudget, MissionReportSchedule, MissionStatus } from '@/types'
+import type { Mission, MissionBudget, MissionReportSchedule, MissionStatus, MissionTemplate } from '@/types'
 import { DEFAULT_MISSION_WARN_FRACTIONS } from '@/types'
 import { hmrSingleton } from '@/lib/shared-utils'
 import { log } from '@/lib/server/logger'
@@ -11,6 +11,7 @@ import {
   patchMission,
   upsertMission,
 } from './mission-repository'
+import { getMissionTemplate } from './mission-templates'
 
 const TAG = 'mission-service'
 
@@ -59,6 +60,7 @@ export interface CreateMissionInput {
   budget?: Partial<MissionBudget>
   reportSchedule?: MissionReportSchedule | null
   reportConnectorIds?: string[]
+  templateId?: string | null
 }
 
 function newMissionId(): string {
@@ -82,6 +84,9 @@ function sanitizeBudget(input: Partial<MissionBudget> = {}): MissionBudget {
 
 export function createMission(input: CreateMissionInput): Mission {
   const now = Date.now()
+  const templateId = typeof input.templateId === 'string' && input.templateId.trim()
+    ? input.templateId.trim().slice(0, 64)
+    : null
   const mission: Mission = {
     id: newMissionId(),
     title: input.title.trim(),
@@ -106,12 +111,53 @@ export function createMission(input: CreateMissionInput): Mission {
     reportConnectorIds: input.reportConnectorIds ?? [],
     createdAt: now,
     updatedAt: now,
+    templateId,
   }
   upsertMission(mission)
   log.info(TAG, `Created mission ${mission.id} (goal: ${mission.goal.slice(0, 80)})`)
   return mission
 }
 
+export interface CreateMissionFromTemplateInput {
+  templateId: string
+  rootSessionId: string
+  overrides?: {
+    title?: string
+    goal?: string
+    successCriteria?: string[]
+    budget?: Partial<MissionBudget>
+    reportSchedule?: MissionReportSchedule | null
+    agentIds?: string[]
+    reportConnectorIds?: string[]
+  }
+}
+
+export interface CreateMissionFromTemplateResult {
+  mission: Mission
+  template: MissionTemplate
+}
+
+export function createMissionFromTemplate(input: CreateMissionFromTemplateInput): CreateMissionFromTemplateResult | null {
+  const template = getMissionTemplate(input.templateId)
+  if (!template) return null
+  const overrides = input.overrides ?? {}
+  const mergedBudget: Partial<MissionBudget> = { ...template.defaults.budget, ...(overrides.budget ?? {}) }
+  const mission = createMission({
+    title: overrides.title?.trim() || template.defaults.title,
+    goal: overrides.goal?.trim() || template.defaults.goal,
+    successCriteria: overrides.successCriteria ?? template.defaults.successCriteria,
+    rootSessionId: input.rootSessionId,
+    agentIds: overrides.agentIds ?? [],
+    budget: mergedBudget,
+    reportSchedule: overrides.reportSchedule === undefined
+      ? template.defaults.reportSchedule
+      : overrides.reportSchedule,
+    reportConnectorIds: overrides.reportConnectorIds ?? [],
+    templateId: template.id,
+  })
+  return { mission, template }
+}
+
 function applyStatusTransition(
   id: string,
   next: MissionStatus,