@swarmclawai/swarmclaw 0.6.2 → 0.6.4

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

@@ -159,17 +159,31 @@ function parseKeyValueArgs(raw: string): Record<string, string> {
 }
 
 function extractConnectorMessageArgs(message: string): {
-  action: 'list_running' | 'list_targets' | 'send'
+  action:
+    | 'list_running'
+    | 'list_targets'
+    | 'start'
+    | 'stop'
+    | 'send'
+    | 'send_voice_note'
+    | 'schedule_followup'
   platform?: string
   connectorId?: string
   to?: string
   message?: string
+  voiceText?: string
+  voiceId?: string
   imageUrl?: string
   fileUrl?: string
   mediaPath?: string
   mimeType?: string
   fileName?: string
   caption?: string
+  delaySec?: number
+  followUpMessage?: string
+  followUpDelaySec?: number
+  ptt?: boolean
+  approved?: boolean
 } | null {
   if (!message.toLowerCase().includes('connector_message_tool')) return null
   const parsed = parseKeyValueArgs(message)
@@ -190,21 +204,43 @@ function extractConnectorMessageArgs(message: string): {
   }
 
   const actionRaw = (parsed.action || 'send').toLowerCase()
-  const action = actionRaw === 'list_running' || actionRaw === 'list_targets' || actionRaw === 'send'
+  const action = (
+    actionRaw === 'list_running'
+    || actionRaw === 'list_targets'
+    || actionRaw === 'start'
+    || actionRaw === 'stop'
+    || actionRaw === 'send'
+    || actionRaw === 'send_voice_note'
+    || actionRaw === 'schedule_followup'
+  )
     ? actionRaw
     : 'send'
   const args: {
-    action: 'list_running' | 'list_targets' | 'send'
+    action:
+      | 'list_running'
+      | 'list_targets'
+      | 'start'
+      | 'stop'
+      | 'send'
+      | 'send_voice_note'
+      | 'schedule_followup'
     platform?: string
     connectorId?: string
     to?: string
     message?: string
+    voiceText?: string
+    voiceId?: string
     imageUrl?: string
     fileUrl?: string
     mediaPath?: string
     mimeType?: string
     fileName?: string
     caption?: string
+    delaySec?: number
+    followUpMessage?: string
+    followUpDelaySec?: number
+    ptt?: boolean
+    approved?: boolean
   } = { action }
   const quoted = (key: string): string | undefined => {
     const m = message.match(new RegExp(`${key}\\s*=\\s*(\"([^\"]*)\"|'([^']*)')`, 'i'))
@@ -214,12 +250,19 @@ function extractConnectorMessageArgs(message: string): {
   if (parsed.connectorId) args.connectorId = parsed.connectorId
   if (parsed.to) args.to = parsed.to
   if (payload) args.message = payload
+  if (parsed.voiceText) args.voiceText = parsed.voiceText
+  if (parsed.voiceId) args.voiceId = parsed.voiceId
   args.imageUrl = parsed.imageUrl || quoted('imageUrl')
   args.fileUrl = parsed.fileUrl || quoted('fileUrl')
   args.mediaPath = parsed.mediaPath || quoted('mediaPath')
   args.mimeType = parsed.mimeType || quoted('mimeType')
   args.fileName = parsed.fileName || quoted('fileName')
   args.caption = parsed.caption || quoted('caption')
+  if (parsed.followUpMessage) args.followUpMessage = parsed.followUpMessage
+  if (parsed.delaySec && Number.isFinite(Number(parsed.delaySec))) args.delaySec = Number(parsed.delaySec)
+  if (parsed.followUpDelaySec && Number.isFinite(Number(parsed.followUpDelaySec))) args.followUpDelaySec = Number(parsed.followUpDelaySec)
+  if (parsed.ptt) args.ptt = ['true', '1', 'yes', 'on'].includes(parsed.ptt.toLowerCase())
+  if (parsed.approved) args.approved = ['true', '1', 'yes', 'on'].includes(parsed.approved.toLowerCase())
   return args
 }
 
@@ -285,6 +328,21 @@ function findFirstUrl(text: string): string | null {
   return m?.[0] || null
 }
 
+function isMemoryListIntent(message: string): boolean {
+  const text = message.toLowerCase()
+  if (!/\bmemory|memories|remember\b/.test(text)) return false
+  if (/\b(save|store|memorize|add to memory|write to memory|remember this)\b/.test(text)) return false
+  if (/\bmemory_tool\b/.test(text)) return true
+  return (
+    /\blist\b[\s\w]{0,24}\bmemories\b/.test(text)
+    || /\bshow\b[\s\w]{0,24}\bmemories\b/.test(text)
+    || /\bget\b[\s\w]{0,24}\bmemories\b/.test(text)
+    || /\bwhat\b[\s\w]{0,40}\bmemories\b/.test(text)
+    || /\bwhat do you remember\b/.test(text)
+    || /\brecall\b[\s\w]{0,24}\bmemories?\b/.test(text)
+  )
+}
+
 function syncSessionFromAgent(sessionId: string): void {
   const sessions = loadSessions()
   const session = sessions[sessionId]
@@ -847,6 +905,19 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     }
   }
 
+  if (
+    canAutoRouteWithTools
+    && calledNames.size === 0
+    && hasToolEnabled(sessionForRun, 'memory')
+    && isMemoryListIntent(message)
+  ) {
+    await invokeSessionTool(
+      'memory_tool',
+      { action: 'list', key: '', scope: 'auto' },
+      'Auto memory listing failed',
+    )
+  }
+
   if (requestedToolNames.length > 0) {
     const missed = requestedToolNames.filter((name) => !calledNames.has(name))
     if (missed.length > 0) {

package/src/lib/server/connectors/connector-routing.test.ts

@@ -1,9 +1,12 @@
 import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
-import { getPlatform, isNoMessage, formatMediaLine, formatInboundUserText } from './manager.ts'
+import { getPlatform, isNoMessage, formatMediaLine, formatInboundUserText, extractEmbeddedMedia, selectOutboundMediaFiles } from './manager.ts'
 import { handleSignalEvent } from './signal.ts'
 import type { PlatformConnector } from './types.ts'
 import type { InboundMessage, InboundMedia } from './types.ts'
+import fs from 'node:fs'
+import path from 'node:path'
+import { UPLOAD_DIR } from '../storage'
 
 // ---------------------------------------------------------------------------
 // 1. Connector module resolution (getPlatform)
@@ -241,3 +244,117 @@ describe('formatInboundUserText', () => {
     assert.ok(result.includes('...and 2 more attachment(s)'))
   })
 })
+
+// ---------------------------------------------------------------------------
+// 6. extractEmbeddedMedia
+// ---------------------------------------------------------------------------
+describe('extractEmbeddedMedia', () => {
+  it('extracts markdown image and file links for uploaded assets', async () => {
+    fs.mkdirSync(UPLOAD_DIR, { recursive: true })
+    const token = `test-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`
+    const imgName = `${token}-foo.png`
+    const pdfName = `${token}-report.pdf`
+    const img = path.join(UPLOAD_DIR, imgName)
+    const pdf = path.join(UPLOAD_DIR, pdfName)
+    fs.writeFileSync(img, 'img')
+    fs.writeFileSync(pdf, 'pdf')
+
+    try {
+      const input = [
+        'Here you go:',
+        `![chart](/api/uploads/${imgName})`,
+        `[Report](/api/uploads/${pdfName})`,
+      ].join('\n')
+
+      const out = extractEmbeddedMedia(input)
+      assert.equal(out.files.length, 2)
+      assert.equal(out.files[0].path, img)
+      assert.equal(out.files[0].alt, 'chart')
+      assert.equal(out.files[1].path, pdf)
+      assert.equal(out.files[1].alt, 'Report')
+      assert.equal(out.cleanText, 'Here you go:')
+    } finally {
+      fs.rmSync(img, { force: true })
+      fs.rmSync(pdf, { force: true })
+    }
+  })
+
+  it('extracts bare /api/uploads URLs and de-duplicates duplicate references', async () => {
+    fs.mkdirSync(UPLOAD_DIR, { recursive: true })
+    const token = `test-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`
+    const pdfName = `${token}-duplicate.pdf`
+    const pdf = path.join(UPLOAD_DIR, pdfName)
+    fs.writeFileSync(pdf, 'pdf')
+    try {
+      const input = [
+        `File: /api/uploads/${pdfName}`,
+        `[Again](/api/uploads/${pdfName})`,
+      ].join('\n')
+      const out = extractEmbeddedMedia(input)
+      assert.equal(out.files.length, 1)
+      assert.equal(out.files[0].path, pdf)
+      assert.equal(out.cleanText, 'File:')
+    } finally {
+      fs.rmSync(pdf, { force: true })
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 7. selectOutboundMediaFiles
+// ---------------------------------------------------------------------------
+describe('selectOutboundMediaFiles', () => {
+  it('deduplicates browser/screenshot variants and selects one file by default', () => {
+    fs.mkdirSync(UPLOAD_DIR, { recursive: true })
+    const ts = Date.now()
+    const browserPng = path.join(UPLOAD_DIR, `browser-${ts}.png`)
+    const screenshotPng = path.join(UPLOAD_DIR, `screenshot-${ts + 1}.png`)
+    const finalPng = path.join(UPLOAD_DIR, `${Date.now()}-wikipedia_screenshot.png`)
+    fs.writeFileSync(browserPng, 'browser')
+    fs.writeFileSync(screenshotPng, 'shot')
+    fs.writeFileSync(finalPng, 'final')
+    try {
+      const selected = selectOutboundMediaFiles(
+        [
+          { path: browserPng, alt: 'Screenshot' },
+          { path: screenshotPng, alt: 'Screenshot' },
+          { path: finalPng, alt: 'wikipedia_screenshot.png' },
+        ],
+        'Can you send me a screenshot of Wikipedia?',
+      )
+      assert.equal(selected.length, 1)
+      assert.equal(selected[0].path, finalPng)
+    } finally {
+      fs.rmSync(browserPng, { force: true })
+      fs.rmSync(screenshotPng, { force: true })
+      fs.rmSync(finalPng, { force: true })
+    }
+  })
+
+  it('allows multiple files only when the user explicitly asks for many', () => {
+    fs.mkdirSync(UPLOAD_DIR, { recursive: true })
+    const ts = Date.now()
+    const browserPng = path.join(UPLOAD_DIR, `browser-${ts}.png`)
+    const screenshotPng = path.join(UPLOAD_DIR, `screenshot-${ts + 1}.png`)
+    const pdf = path.join(UPLOAD_DIR, `${Date.now()}-report.pdf`)
+    fs.writeFileSync(browserPng, 'browser')
+    fs.writeFileSync(screenshotPng, 'shot')
+    fs.writeFileSync(pdf, 'pdf')
+    try {
+      const selected = selectOutboundMediaFiles(
+        [
+          { path: browserPng, alt: 'Screenshot' },
+          { path: screenshotPng, alt: 'Screenshot' },
+          { path: pdf, alt: 'Report' },
+        ],
+        'Send both screenshots and the PDF',
+      )
+      assert.equal(selected.length, 2)
+      assert.deepEqual(selected.map((f) => path.basename(f.path)).sort(), [path.basename(browserPng), path.basename(pdf)].sort())
+    } finally {
+      fs.rmSync(browserPng, { force: true })
+      fs.rmSync(screenshotPng, { force: true })
+      fs.rmSync(pdf, { force: true })
+    }
+  })
+})

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

@@ -3,7 +3,7 @@ import fs from 'fs'
 import path from 'path'
 import type { Connector } from '@/types'
 import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
-import { inferInboundMediaType, mimeFromPath, isImageMime } from './media'
+import { downloadInboundMediaToUpload, inferInboundMediaType } from './media'
 import { isNoMessage } from './manager'
 
 const discord: PlatformConnector = {
@@ -32,13 +32,36 @@ const discord: PlatformConnector = {
       if (allowedChannels && !allowedChannels.includes(message.channelId)) return
 
       const attachmentList = Array.from(message.attachments.values())
-      const media = attachmentList.map((a) => ({
-        type: inferInboundMediaType(a.contentType || undefined, a.name || undefined),
-        fileName: a.name || undefined,
-        mimeType: a.contentType || undefined,
-        sizeBytes: a.size || undefined,
-        url: a.url || undefined,
-      }))
+      const media: NonNullable<InboundMessage['media']> = []
+      for (const attachment of attachmentList) {
+        const mediaType = inferInboundMediaType(attachment.contentType || undefined, attachment.name || undefined)
+        const sourceUrl = attachment.url || undefined
+        if (sourceUrl) {
+          try {
+            const stored = await downloadInboundMediaToUpload({
+              connectorId: connector.id,
+              mediaType,
+              url: sourceUrl,
+              fileName: attachment.name || undefined,
+              mimeType: attachment.contentType || undefined,
+            })
+            if (stored) {
+              media.push(stored)
+              continue
+            }
+          } catch (err: unknown) {
+            const errMsg = err instanceof Error ? err.message : String(err)
+            console.warn(`[discord] Media download failed (${attachment.name || 'file'}):`, errMsg)
+          }
+        }
+        media.push({
+          type: mediaType,
+          fileName: attachment.name || undefined,
+          mimeType: attachment.contentType || undefined,
+          sizeBytes: attachment.size || undefined,
+          url: sourceUrl,
+        })
+      }
       const firstImage = media.find((m) => m.type === 'image' && m.url)
 
       const inbound: InboundMessage = {