@swarmclawai/swarmclaw 1.4.0 → 1.4.3

package/src/lib/server/safe-parse-body.ts

@@ -1,4 +1,7 @@
 import { NextResponse } from 'next/server'
+import { z } from 'zod'
+
+import { formatZodError } from '@/lib/validation/schemas'
 
 type SafeResult<T> = { data: T; error?: never } | { data?: never; error: NextResponse }
 
@@ -6,11 +9,25 @@ type SafeResult<T> = { data: T; error?: never } | { data?: never; error: NextRes
  * Wraps `req.json()` so malformed/empty bodies return a 400
  * instead of throwing an unhandled error (500).
  */
-export async function safeParseBody<T = Record<string, unknown>>(req: Request): Promise<SafeResult<T>> {
+export async function safeParseBody<T = Record<string, unknown>>(
+  req: Request,
+  schema?: z.ZodType<T>,
+): Promise<SafeResult<T>> {
+  let raw: unknown
   try {
-    const data = (await req.json()) as T
-    return { data }
+    raw = await req.json()
   } catch {
     return { error: NextResponse.json({ error: 'Invalid or missing request body' }, { status: 400 }) }
   }
+
+  if (!schema) {
+    return { data: raw as T }
+  }
+
+  const parsed = schema.safeParse(raw)
+  if (!parsed.success) {
+    return { error: NextResponse.json(formatZodError(parsed.error), { status: 400 }) }
+  }
+
+  return { data: parsed.data }
 }

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

@@ -44,6 +44,8 @@ import { buildSkillsTools } from './skills-tool'
 import { buildFilesTools } from './files-tool'
 import { buildMemoryTool } from './memory-tool'
 import { buildPlatformV2Tools } from './platform-tool'
+import { buildSwarmFeedTools } from './swarmfeed'
+import { buildSwarmDockTools } from './swarmdock'
 import './connector'
 import { normalizeToolInputArgs } from './normalize-tool-args'
 import { enforceFileAccessPolicy } from './file-access-policy'
@@ -208,6 +210,8 @@ export async function buildSessionTools(cwd: string, enabledExtensions: string[]
       ['files_v2', buildFilesTools],
       ['memory_v2', buildMemoryTool],
       ['platform_v2', buildPlatformV2Tools],
+      ['swarmfeed', buildSwarmFeedTools],
+      ['swarmdock', buildSwarmDockTools],
     ]
 
     for (const [extensionId, builder] of nativeBuilders) {

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

@@ -0,0 +1,104 @@
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import { getAgent } from '@/lib/server/agents/agent-repository'
+import { log } from '@/lib/server/logger'
+import type { ToolBuildContext } from './context'
+import type { Agent } from '@/types'
+
+const TAG = 'swarmdock-tool'
+
+const SWARMDOCK_SCHEMA = z.object({
+  action: z.enum(['browse_tasks', 'check_status', 'list_skills', 'get_agent_profile']).describe(
+    'The SwarmDock marketplace action to perform',
+  ),
+  taskId: z.string().optional().describe('Task ID for task-specific actions'),
+  skillFilter: z.string().optional().describe('Filter tasks by skill (e.g. "data-analysis")'),
+  limit: z.number().optional().describe('Number of results to return (default: 10)'),
+})
+
+type SwarmDockInput = z.infer<typeof SWARMDOCK_SCHEMA>
+
+async function executeSwarmDock(input: SwarmDockInput, bctx: ToolBuildContext): Promise<string> {
+  const agentId = bctx.ctx?.agentId
+  if (!agentId) return JSON.stringify({ error: 'No agent context' })
+
+  const agent = getAgent(agentId) as Agent | undefined
+  if (!agent) return JSON.stringify({ error: 'Agent not found' })
+  if (!agent.swarmdockEnabled) return JSON.stringify({ error: 'SwarmDock is not enabled for this agent' })
+
+  try {
+    switch (input.action) {
+      case 'browse_tasks': {
+        const apiUrl = process.env.SWARMDOCK_API_URL || 'https://swarmdock-api.onrender.com'
+        const res = await fetch(`${apiUrl}/api/v1/tasks?limit=${input.limit || 10}${input.skillFilter ? `&skill=${input.skillFilter}` : ''}`)
+        if (!res.ok) {
+          const text = await res.text().catch(() => 'Unknown error')
+          return JSON.stringify({ error: `SwarmDock API error ${res.status}: ${text}` })
+        }
+        const data = await res.json()
+        return JSON.stringify({ tasks: data.tasks || data })
+      }
+
+      case 'check_status': {
+        return JSON.stringify({
+          agent: agent.name,
+          swarmdockEnabled: agent.swarmdockEnabled,
+          swarmdockAgentId: agent.swarmdockAgentId || null,
+          swarmdockDid: agent.swarmdockDid || null,
+          listedAt: agent.swarmdockListedAt || null,
+          skills: agent.swarmdockSkills || [],
+          description: agent.swarmdockDescription || null,
+          marketplace: agent.swarmdockMarketplace || null,
+        })
+      }
+
+      case 'list_skills': {
+        return JSON.stringify({
+          agentSkills: agent.swarmdockSkills || [],
+          description: agent.swarmdockDescription || null,
+        })
+      }
+
+      case 'get_agent_profile': {
+        return JSON.stringify({
+          name: agent.name,
+          description: agent.swarmdockDescription || agent.description || null,
+          skills: agent.swarmdockSkills || [],
+          swarmdockAgentId: agent.swarmdockAgentId || null,
+          swarmdockDid: agent.swarmdockDid || null,
+          walletId: agent.swarmdockWalletId || null,
+          marketplace: agent.swarmdockMarketplace || null,
+        })
+      }
+
+      default:
+        return JSON.stringify({ error: `Unknown action: ${input.action}` })
+    }
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : 'Unknown error'
+    log.error(TAG, `Action "${input.action}" failed for agent "${agent.name}": ${message}`)
+    return JSON.stringify({ error: message })
+  }
+}
+
+export function buildSwarmDockTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  const agentId = bctx.ctx?.agentId
+  if (!agentId) return []
+
+  const agent = getAgent(agentId) as Agent | undefined
+  if (!agent?.swarmdockEnabled) return []
+
+  return [
+    tool(
+      async (args) => executeSwarmDock(args as SwarmDockInput, bctx),
+      {
+        name: 'swarmdock',
+        description:
+          'Interact with SwarmDock, the AI agent marketplace. ' +
+          'Actions: browse_tasks (find available tasks), check_status (check marketplace registration status), ' +
+          'list_skills (view configured skills), get_agent_profile (view marketplace profile).',
+        schema: SWARMDOCK_SCHEMA,
+      },
+    ),
+  ]
+}

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

@@ -0,0 +1,150 @@
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import { getAgent, patchAgent } from '@/lib/server/agents/agent-repository'
+import { createPost, getFeed, likePost, repostPost, getChannels, registerAgent } from '@/lib/swarmfeed-client'
+import { log } from '@/lib/server/logger'
+import type { ToolBuildContext } from './context'
+import type { Agent } from '@/types'
+
+const TAG = 'swarmfeed-tool'
+
+const SWARMFEED_SCHEMA = z.object({
+  action: z.enum(['post', 'reply', 'like', 'repost', 'browse_feed', 'get_channels']).describe(
+    'The SwarmFeed action to perform',
+  ),
+  content: z.string().optional().describe('Post content (required for post/reply)'),
+  postId: z.string().optional().describe('Post ID (required for reply/like/repost)'),
+  channelId: z.string().optional().describe('Channel ID for posting to a channel or browsing a channel feed'),
+  feedType: z.enum(['for_you', 'following', 'trending', 'channel']).optional().describe('Feed type for browse_feed (default: for_you)'),
+  limit: z.number().optional().describe('Number of posts to fetch for browse_feed (default: 10)'),
+})
+
+type SwarmFeedInput = z.infer<typeof SWARMFEED_SCHEMA>
+
+async function ensureApiKey(agent: Agent): Promise<string> {
+  if (agent.swarmfeedApiKey) return agent.swarmfeedApiKey
+
+  log.info(TAG, `Auto-registering agent "${agent.name}" on SwarmFeed`)
+  const reg = await registerAgent({
+    name: agent.name,
+    description: agent.description || agent.swarmfeedBio || `${agent.name} agent on SwarmClaw`,
+    framework: 'swarmclaw',
+    model: agent.model,
+    avatar: agent.avatarUrl || undefined,
+    bio: agent.swarmfeedBio || undefined,
+  })
+
+  patchAgent(agent.id, (current) => {
+    if (!current) return null
+    return {
+      ...current,
+      swarmfeedApiKey: reg.apiKey,
+      swarmfeedAgentId: reg.agentId,
+      swarmfeedJoinedAt: current.swarmfeedJoinedAt ?? Date.now(),
+      updatedAt: Date.now(),
+    }
+  })
+
+  return reg.apiKey
+}
+
+async function executeSwarmFeed(input: SwarmFeedInput, bctx: ToolBuildContext): Promise<string> {
+  const agentId = bctx.ctx?.agentId
+  if (!agentId) return JSON.stringify({ error: 'No agent context' })
+
+  const agent = getAgent(agentId) as Agent | undefined
+  if (!agent) return JSON.stringify({ error: 'Agent not found' })
+  if (!agent.swarmfeedEnabled) return JSON.stringify({ error: 'SwarmFeed is not enabled for this agent' })
+
+  try {
+    switch (input.action) {
+      case 'post': {
+        if (!input.content?.trim()) return JSON.stringify({ error: 'content is required for post action' })
+        const apiKey = await ensureApiKey(agent)
+        const post = await createPost(apiKey, {
+          content: input.content.trim(),
+          channelId: input.channelId,
+        })
+        return JSON.stringify({ success: true, post: { id: post.id, content: post.content, createdAt: post.createdAt } })
+      }
+
+      case 'reply': {
+        if (!input.content?.trim()) return JSON.stringify({ error: 'content is required for reply action' })
+        if (!input.postId) return JSON.stringify({ error: 'postId is required for reply action' })
+        const apiKey = await ensureApiKey(agent)
+        const reply = await createPost(apiKey, {
+          content: input.content.trim(),
+          parentId: input.postId,
+          channelId: input.channelId,
+        })
+        return JSON.stringify({ success: true, post: { id: reply.id, content: reply.content, parentId: input.postId, createdAt: reply.createdAt } })
+      }
+
+      case 'like': {
+        if (!input.postId) return JSON.stringify({ error: 'postId is required for like action' })
+        const apiKey = await ensureApiKey(agent)
+        await likePost(apiKey, input.postId)
+        return JSON.stringify({ success: true, action: 'liked', postId: input.postId })
+      }
+
+      case 'repost': {
+        if (!input.postId) return JSON.stringify({ error: 'postId is required for repost action' })
+        const apiKey = await ensureApiKey(agent)
+        await repostPost(apiKey, input.postId)
+        return JSON.stringify({ success: true, action: 'reposted', postId: input.postId })
+      }
+
+      case 'browse_feed': {
+        const feedType = input.feedType || 'for_you'
+        const limit = input.limit || 10
+        const apiKey = agent.swarmfeedApiKey || undefined
+        const result = await getFeed(feedType, { channelId: input.channelId, limit }, apiKey)
+        const posts = result.posts.map((p) => ({
+          id: p.id,
+          agent: p.agentId,
+          content: p.content.slice(0, 500),
+          likes: p.likeCount,
+          replies: p.replyCount,
+          reposts: p.repostCount,
+          createdAt: p.createdAt,
+        }))
+        return JSON.stringify({ posts, nextCursor: result.nextCursor })
+      }
+
+      case 'get_channels': {
+        const channels = await getChannels()
+        return JSON.stringify({ channels: channels.map((c) => ({ id: c.id, name: c.displayName, handle: c.handle })) })
+      }
+
+      default:
+        return JSON.stringify({ error: `Unknown action: ${input.action}` })
+    }
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : 'Unknown error'
+    log.error(TAG, `Action "${input.action}" failed for agent "${agent.name}": ${message}`)
+    return JSON.stringify({ error: message })
+  }
+}
+
+export function buildSwarmFeedTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  // Only provide tool if the agent has SwarmFeed enabled
+  const agentId = bctx.ctx?.agentId
+  if (!agentId) return []
+
+  const agent = getAgent(agentId) as Agent | undefined
+  if (!agent?.swarmfeedEnabled) return []
+
+  return [
+    tool(
+      async (args) => executeSwarmFeed(args as SwarmFeedInput, bctx),
+      {
+        name: 'swarmfeed',
+        description:
+          'Interact with SwarmFeed, the social network for AI agents. ' +
+          'Actions: post (publish a post), reply (reply to a post), like, repost, ' +
+          'browse_feed (read the feed), get_channels (list available channels).',
+        schema: SWARMFEED_SCHEMA,
+      },
+    ),
+  ]
+}

package/src/lib/server/storage-normalization.ts

@@ -528,6 +528,16 @@ function normalizeStoredRecordInner(
     if (typeof agent.swarmfeedAgentId !== 'string' && agent.swarmfeedAgentId !== null) agent.swarmfeedAgentId = null
     if (!agent.origin) agent.origin = 'swarmclaw'
     if (agent.swarmfeedHeartbeat === undefined) agent.swarmfeedHeartbeat = null
+    // SwarmDock defaults
+    if (typeof agent.swarmdockEnabled !== 'boolean') agent.swarmdockEnabled = false
+    if (agent.swarmdockListedAt === undefined) agent.swarmdockListedAt = null
+    if (typeof agent.swarmdockDescription !== 'string' && agent.swarmdockDescription !== null) agent.swarmdockDescription = null
+    if (!Array.isArray(agent.swarmdockSkills)) agent.swarmdockSkills = []
+    if (typeof agent.swarmdockWalletId !== 'string' && agent.swarmdockWalletId !== null) agent.swarmdockWalletId = null
+    if (typeof agent.swarmdockAgentId !== 'string' && agent.swarmdockAgentId !== null) agent.swarmdockAgentId = null
+    if (typeof agent.swarmdockDid !== 'string' && agent.swarmdockDid !== null) agent.swarmdockDid = null
+    if (typeof agent.swarmdockApiKey !== 'string' && agent.swarmdockApiKey !== null) agent.swarmdockApiKey = null
+    if (agent.swarmdockMarketplace === undefined) agent.swarmdockMarketplace = null
     // Org chart normalization
     if (agent.orgChart && typeof agent.orgChart === 'object' && !Array.isArray(agent.orgChart)) {
       const oc = agent.orgChart as Record<string, unknown>

package/src/lib/server/storage.ts

@@ -6,12 +6,13 @@ import Database from 'better-sqlite3'
 import { perf } from '@/lib/server/runtime/perf'
 import { log } from '@/lib/server/logger'
 import { notify } from '@/lib/server/ws-hub'
-
-const TAG = 'storage'
 import { DATA_DIR, IS_BUILD_BOOTSTRAP, WORKSPACE_DIR } from './data-dir'
 import { normalizeHeartbeatSettingFields } from '@/lib/runtime/heartbeat-defaults'
 import { normalizeRuntimeSettingFields } from '@/lib/runtime/runtime-loop'
 import { normalizeCapabilitySelection } from '@/lib/capability-selection'
+
+const TAG = 'storage'
+const malformedRecordWarnings = new Set<string>()
 import type {
   Agent,
   AppNotification,
@@ -236,8 +237,16 @@ function loadCollectionWithNormalizationState(table: string): {
       if (!normalized || typeof normalized !== 'object' || Array.isArray(normalized)) continue
       result[id] = normalized as StoredObject
       if (changed) normalizedCount += 1
-    } catch {
-      // Ignore malformed records instead of crashing list endpoints.
+    } catch (err) {
+      const fingerprint = `${table}:${id}`
+      if (!malformedRecordWarnings.has(fingerprint)) {
+        malformedRecordWarnings.add(fingerprint)
+        log.warn(TAG, 'Ignoring malformed stored record during collection load', {
+          table,
+          id,
+          error: err instanceof Error ? err.message : String(err),
+        })
+      }
     }
   }
   endPerf({ count: raw.size, normalizedCount })

package/src/lib/swarmfeed-client.ts

@@ -6,7 +6,7 @@ interface SwarmFeedConfig {
 }
 
 const config = hmrSingleton<SwarmFeedConfig>('swarmfeed_config', () => ({
-  apiUrl: process.env.SWARMFEED_API_URL || 'http://localhost:3700',
+  apiUrl: process.env.SWARMFEED_API_URL || 'https://swarmfeed-api.onrender.com',
 }))
 
 /**

package/src/lib/tool-definitions.ts

@@ -29,6 +29,8 @@ export const AVAILABLE_TOOLS: ToolDefinition[] = [
   { id: 'email', label: 'Email', description: 'Send emails via SMTP with plain text and HTML support', extensionId: 'email' },
   { id: 'replicate', label: 'Replicate', description: 'Run any AI model on Replicate — image generation, LLMs, audio, video, and more', extensionId: 'replicate' },
   { id: 'google_workspace', label: 'Google Workspace', description: 'Run Google Workspace CLI (`gws`) commands for Drive, Docs, Sheets, Gmail, Calendar, Chat, and more', extensionId: 'google_workspace' },
+  { id: 'swarmfeed', label: 'SwarmFeed', description: 'Post, reply, like, repost, and browse the SwarmFeed social network (auto-enabled when SwarmFeed is on)' },
+  { id: 'swarmdock', label: 'SwarmDock', description: 'Browse tasks, check status, and manage marketplace profile on SwarmDock (auto-enabled when SwarmDock is on)' },
 ]
 
 /**

package/src/types/agent.ts

@@ -14,6 +14,18 @@ export interface SwarmFeedHeartbeatConfig {
   channelsToMonitor: string[]
 }
 
+// --- SwarmDock Marketplace ---
+
+export interface SwarmDockMarketplaceConfig {
+  enabled: boolean
+  autoDiscover: boolean
+  maxBudgetUsdc: string
+  autoBid: boolean
+  autoBidMaxPrice: string
+  taskNotifications: boolean
+  preferredCategories: string[]
+}
+
 // --- Agent / Delegation ---
 
 export type AgentRole = 'worker' | 'coordinator'
@@ -203,6 +215,17 @@ export interface Agent {
   origin?: 'swarmdock' | 'swarmfeed' | 'swarmclaw' | 'external'
   swarmfeedHeartbeat?: SwarmFeedHeartbeatConfig | null
 
+  // SwarmDock (marketplace integration)
+  swarmdockEnabled?: boolean
+  swarmdockListedAt?: number | null
+  swarmdockDescription?: string | null
+  swarmdockSkills?: string[]
+  swarmdockWalletId?: string | null
+  swarmdockAgentId?: string | null
+  swarmdockDid?: string | null
+  swarmdockApiKey?: string | null
+  swarmdockMarketplace?: SwarmDockMarketplaceConfig | null
+
   createdAt: number
   updatedAt: number
 }

package/src/types/session.ts

@@ -214,4 +214,4 @@ export type SessionTool =
   | 'crawl'
 
 export type SessionType = 'human'
-export type AppView = 'home' | 'agents' | 'org_chart' | 'inbox' | 'chatrooms' | 'protocols' | 'schedules' | 'memory' | 'tasks' | 'secrets' | 'wallets' | 'providers' | 'skills' | 'connectors' | 'webhooks' | 'mcp_servers' | 'knowledge' | 'extensions' | 'usage' | 'runs' | 'autonomy' | 'logs' | 'settings' | 'projects' | 'activity' | 'swarmfeed'
+export type AppView = 'home' | 'agents' | 'org_chart' | 'inbox' | 'chatrooms' | 'protocols' | 'schedules' | 'memory' | 'tasks' | 'secrets' | 'wallets' | 'providers' | 'skills' | 'connectors' | 'webhooks' | 'mcp_servers' | 'knowledge' | 'extensions' | 'usage' | 'runs' | 'autonomy' | 'logs' | 'settings' | 'projects' | 'activity' | 'swarmfeed' | 'marketplace'

package/tsconfig.json

@@ -33,9 +33,8 @@
     "**/*.ts",
     "**/*.tsx",
     ".next/types/**/*.ts",
-    ".next/dev/types/**/*.ts",
     "**/*.mts",
-    ".next/dev/dev/types/**/*.ts"
+    ".next/dev/types/**/*.ts"
   ],
   "exclude": [
     "node_modules",

package/src/.env.local

@@ -1,4 +0,0 @@
-
-CREDENTIAL_SECRET=903abc19d0ffc461795f39d90f55b68cdc2c35e930f1115374f11a4ff7ddd293
-
-ACCESS_KEY=9cf202df60e837ff327ae4e16b257d1f