@swarmclawai/swarmclaw 0.6.2 → 0.6.4

package/src/lib/server/session-tools/file.ts

@@ -6,6 +6,17 @@ import { UPLOAD_DIR } from '../storage'
 import type { ToolBuildContext } from './context'
 import { safePath, truncate, listDirRecursive, MAX_OUTPUT, MAX_FILE } from './context'
 
+const SEND_FILE_DEDUPE_TTL_MS = 30_000
+const recentSendFileResults = new Map<string, { at: number; output: string; uploadPath: string }>()
+
+function pruneRecentSendFileCache(now: number): void {
+  for (const [key, entry] of recentSendFileResults.entries()) {
+    if (now - entry.at > SEND_FILE_DEDUPE_TTL_MS || !fs.existsSync(entry.uploadPath)) {
+      recentSendFileResults.delete(key)
+    }
+  }
+}
+
 export function buildFileTools(bctx: ToolBuildContext): StructuredToolInterface[] {
   const tools: StructuredToolInterface[] = []
 
@@ -197,6 +208,8 @@ export function buildFileTools(bctx: ToolBuildContext): StructuredToolInterface[
       tool(
         async ({ filePath: rawPath }) => {
           try {
+            const now = Date.now()
+            pruneRecentSendFileCache(now)
             // Resolve relative to cwd, but also allow absolute paths
             const resolved = path.isAbsolute(rawPath) ? rawPath : path.resolve(bctx.cwd, rawPath)
             if (!fs.existsSync(resolved)) return `Error: file not found: ${rawPath}`
@@ -204,6 +217,13 @@ export function buildFileTools(bctx: ToolBuildContext): StructuredToolInterface[
             if (stat.isDirectory()) return `Error: cannot send a directory. Send individual files instead.`
             if (stat.size > 100 * 1024 * 1024) return `Error: file too large (${(stat.size / 1024 / 1024).toFixed(1)}MB). Max 100MB.`
 
+            const sessionId = bctx.ctx?.sessionId || 'no-session'
+            const dedupeKey = `${sessionId}|${resolved}`
+            const cached = recentSendFileResults.get(dedupeKey)
+            if (cached && now - cached.at <= SEND_FILE_DEDUPE_TTL_MS && fs.existsSync(cached.uploadPath)) {
+              return cached.output
+            }
+
             const ext = path.extname(resolved).slice(1).toLowerCase()
             const basename = path.basename(resolved)
             const filename = `${Date.now()}-${basename}`
@@ -212,14 +232,13 @@ export function buildFileTools(bctx: ToolBuildContext): StructuredToolInterface[
 
             const IMAGE_EXTS = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg', 'bmp', 'ico']
             const VIDEO_EXTS = ['mp4', 'webm', 'mov', 'avi', 'mkv']
+            const AUDIO_EXTS = ['mp3', 'ogg', 'wav', 'aac', 'm4a', 'opus']
 
-            if (IMAGE_EXTS.includes(ext)) {
-              return `![${basename}](/api/uploads/${filename})`
-            } else if (VIDEO_EXTS.includes(ext)) {
-              return `![${basename}](/api/uploads/${filename})`
-            } else {
-              return `[Download ${basename}](/api/uploads/${filename})`
-            }
+            const output = (IMAGE_EXTS.includes(ext) || VIDEO_EXTS.includes(ext) || AUDIO_EXTS.includes(ext))
+              ? `![${basename}](/api/uploads/${filename})`
+              : `[Download ${basename}](/api/uploads/${filename})`
+            recentSendFileResults.set(dedupeKey, { at: now, output, uploadPath: dest })
+            return output
           } catch (err: unknown) {
             return `Error sending file: ${err instanceof Error ? err.message : String(err)}`
           }

package/src/lib/server/session-tools/web-output.test.ts

@@ -0,0 +1,29 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { dedupeScreenshotMarkdownLines } from './web-output'
+
+describe('dedupeScreenshotMarkdownLines', () => {
+  it('prefers screenshot-* image when both browser-* and screenshot-* variants are present', () => {
+    const parts = [
+      '![Screenshot](/api/uploads/browser-1772498741525.png)',
+      '![Screenshot](/api/uploads/screenshot-1772498741526.png)',
+      'Saved to: example_screenshot.png',
+    ]
+
+    const next = dedupeScreenshotMarkdownLines(parts)
+    assert.deepEqual(next, [
+      '![Screenshot](/api/uploads/screenshot-1772498741526.png)',
+      'Saved to: example_screenshot.png',
+    ])
+  })
+
+  it('keeps single image output untouched', () => {
+    const parts = [
+      '![Screenshot](/api/uploads/browser-1772498741525.png)',
+      'Saved to: example_screenshot.png',
+    ]
+
+    const next = dedupeScreenshotMarkdownLines(parts)
+    assert.deepEqual(next, parts)
+  })
+})

package/src/lib/server/session-tools/web-output.ts

@@ -0,0 +1,16 @@
+export function dedupeScreenshotMarkdownLines(parts: string[]): string[] {
+  const imageLineRe = /^!\[[^\]]*]\(\/api\/uploads\/([^)]+)\)$/
+  const imageLines = parts
+    .map((line, index) => ({ line: line.trim(), index }))
+    .map((entry) => {
+      const match = entry.line.match(imageLineRe)
+      return match ? { ...entry, filename: match[1] } : null
+    })
+    .filter((entry): entry is { line: string; index: number; filename: string } => !!entry)
+
+  if (imageLines.length <= 1) return parts
+
+  const preferred = imageLines.find((entry) => !entry.filename.startsWith('browser-')) || imageLines[0]
+  const keepIndex = preferred.index
+  return parts.filter((_, index) => !imageLines.some((entry) => entry.index === index) || index === keepIndex)
+}

package/src/lib/server/session-tools/web.ts

@@ -8,6 +8,7 @@ import type { ToolBuildContext } from './context'
 import { spawnSync } from 'child_process'
 import { safePath, truncate, MAX_OUTPUT, findBinaryOnPath } from './context'
 import { getSearchProvider } from './search-providers'
+import { dedupeScreenshotMarkdownLines } from './web-output'
 
 // ---------------------------------------------------------------------------
 // Search result compression — summarize verbose results before injecting into context
@@ -277,11 +278,11 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
       }
 
       if (Array.isArray(content)) {
-        const parts: string[] = []
-        let hasBinaryImage = false
+        let parts: string[] = []
+        const isScreenshotTool = toolName === 'browser_take_screenshot'
+        const contentHasBinaryImage = content.some((c) => c.type === 'image' && !!c.data)
         for (const c of content) {
           if (c.type === 'image' && c.data) {
-            hasBinaryImage = true
             const imageBuffer = Buffer.from(c.data, 'base64')
             const filename = `screenshot-${Date.now()}.png`
             const filepath = path.join(UPLOAD_DIR, filename)
@@ -306,8 +307,8 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
               if (fs.existsSync(srcPath)) {
                 const ext = path.extname(srcPath).slice(1).toLowerCase()
                 const IMAGE_EXTS = ['png', 'jpg', 'jpeg', 'gif', 'webp']
-                // Skip file-path images if we already have a binary image (avoids duplicates)
-                if (IMAGE_EXTS.includes(ext) && hasBinaryImage) {
+                // Skip file-path images whenever MCP already returned image binary payloads.
+                if (IMAGE_EXTS.includes(ext) && contentHasBinaryImage) {
                   parts.push(isError ? text : cleanPlaywrightOutput(text))
                 } else {
                   const filename = `browser-${Date.now()}.${ext}`
@@ -335,6 +336,8 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
             }
           }
         }
+        if (isScreenshotTool) parts = dedupeScreenshotMarkdownLines(parts)
+
         if (savedPaths.length > 0) {
           const unique = Array.from(new Set(savedPaths))
           const rendered = unique.map((p) => path.relative(cwd, p) || '.').join(', ')

package/src/lib/server/stream-agent-chat.ts

@@ -127,6 +127,12 @@ function buildAgenticExecutionPolicy(opts: {
     opts.enabledTools.includes('manage_connectors')
       ? 'If the user wants proactive outreach (e.g., WhatsApp updates), configure connectors and pair with schedules/tasks to deliver status updates.'
       : '',
+    opts.enabledTools.includes('manage_connectors')
+      ? 'Autonomous outreach is allowed for significant events (completed/failed tasks, blockers, deadlines, meaningful reminders from memory). Avoid casual or repetitive check-ins.'
+      : '',
+    opts.enabledTools.includes('manage_connectors')
+      ? 'When you proactively message through connectors, keep it concise and purposeful, and avoid sending duplicate updates about the same event.'
+      : '',
     opts.enabledTools.includes('manage_sessions')
       ? 'When coordinating platform work, inspect existing sessions and avoid duplicating active efforts.'
       : '',
@@ -164,6 +170,7 @@ function buildAgenticExecutionPolicy(opts: {
     'The test: if you saw this message from a friend, would you feel compelled to type something back? If not, NO_MESSAGE.',
     'Ask for confirmation only for high-risk or irreversible actions. For normal low-risk research/build steps, proceed autonomously.',
     'Default behavior is execution, not interrogation: do not ask exploratory clarification questions when a safe next action exists.',
+    'Do not end every response with a question. Use declarative completion statements by default, and only ask a question when a concrete missing detail blocks the next action.',
     'Do not pause for a "continue" confirmation after the user has already asked you to execute a goal. Keep moving until blocked by permissions, missing credentials, or hard tool failures.',
     'Never repeat one-time side effects that are already complete (for example creating the same schedule/task again). Verify state first, then either continue execution or reply HEARTBEAT_OK.',
     'For main-loop tick messages that begin with "SWARM_MAIN_MISSION_TICK" or "SWARM_MAIN_AUTO_FOLLOWUP", follow that response contract exactly and include one valid [MAIN_LOOP_META] JSON line when you are not returning HEARTBEAT_OK.',

package/src/lib/view-routes.ts

@@ -49,7 +49,11 @@ export function parsePath(pathname: string): { view: AppView; id: string | null
     if (pathname.startsWith(path + '/')) {
       const rest = pathname.slice(path.length + 1)
       if (rest && !rest.includes('/') && VIEWS_WITH_ID.has(view)) {
-        return { view, id: decodeURIComponent(rest) }
+        try {
+          return { view, id: decodeURIComponent(rest) }
+        } catch {
+          return null
+        }
       }
     }
   }

package/src/stores/use-app-store.ts

@@ -7,6 +7,7 @@ import { fetchAgents } from '../lib/agents'
 import { fetchSchedules } from '../lib/schedules'
 import { fetchTasks } from '../lib/tasks'
 import { api } from '../lib/api-client'
+import { safeStorageGet, safeStorageGetJson, safeStorageRemove, safeStorageSet } from '../lib/safe-storage'
 
 interface AppState {
   currentUser: string | null
@@ -209,14 +210,13 @@ export const useAppStore = create<AppState>((set, get) => ({
   currentUser: null,
   _hydrated: false,
   hydrate: () => {
-    if (typeof window === 'undefined') return
-    const user = localStorage.getItem('sc_user')
-    const savedAgentId = localStorage.getItem('sc_agent')
+    const user = safeStorageGet('sc_user')
+    const savedAgentId = safeStorageGet('sc_agent')
     set({ currentUser: user, currentAgentId: savedAgentId, _hydrated: true })
   },
   setUser: (user) => {
-    if (user) localStorage.setItem('sc_user', user)
-    else localStorage.removeItem('sc_user')
+    if (user) safeStorageSet('sc_user', user)
+    else safeStorageRemove('sc_user')
     set({ currentUser: user })
   },
 
@@ -324,11 +324,11 @@ export const useAppStore = create<AppState>((set, get) => ({
   setCurrentAgent: async (id) => {
     if (!id) {
       set({ currentAgentId: null })
-      if (typeof window !== 'undefined') localStorage.removeItem('sc_agent')
+      safeStorageRemove('sc_agent')
       return
     }
     set({ currentAgentId: id })
-    if (typeof window !== 'undefined') localStorage.setItem('sc_agent', id)
+    safeStorageSet('sc_agent', id)
     try {
       const user = get().currentUser || 'default'
       const session = await api<Session>('POST', `/agents/${id}/thread`, { user })
@@ -628,13 +628,11 @@ export const useAppStore = create<AppState>((set, get) => ({
   },
 
   // Unread tracking
-  lastReadTimestamps: typeof window !== 'undefined'
-    ? (() => { try { return JSON.parse(localStorage.getItem('sc_last_read') || '{}') } catch { return {} } })()
-    : {},
+  lastReadTimestamps: safeStorageGetJson<Record<string, number>>('sc_last_read', {}),
   markChatRead: (id) => {
     const ts = { ...get().lastReadTimestamps, [id]: Date.now() }
     set({ lastReadTimestamps: ts })
-    try { localStorage.setItem('sc_last_read', JSON.stringify(ts)) } catch { /* ignore */ }
+    safeStorageSet('sc_last_read', JSON.stringify(ts))
   },
 
   // Notifications