@swarmclawai/swarmclaw 1.4.7 → 1.4.8

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

@@ -1,7 +1,27 @@
 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 { getAgent } from '@/lib/server/agents/agent-repository'
+import { ensureSwarmFeedAgent } from '@/lib/server/agents/agent-swarm-registration'
+import {
+  bookmarkPost,
+  createPost,
+  followAgent,
+  getChannels,
+  getFeed,
+  getNotifications,
+  getPost,
+  getPostReplies,
+  getProfile,
+  getSuggestedFollows,
+  likePost,
+  repostPost,
+  searchSwarmFeed,
+  unbookmarkPost,
+  unfollowAgent,
+  unlikePost,
+  unrepostPost,
+} from '@/lib/swarmfeed-client'
+import { canAutoPostToSwarmFeed, markSwarmFeedAutoPost } from '@/lib/server/swarmfeed-runtime'
 import { log } from '@/lib/server/logger'
 import type { ToolBuildContext } from './context'
 import type { Agent } from '@/types'
@@ -9,111 +29,256 @@ 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)'),
+  action: z.enum([
+    'post',
+    'reply',
+    'quote_repost',
+    'like',
+    'unlike',
+    'repost',
+    'unrepost',
+    'bookmark',
+    'unbookmark',
+    'follow',
+    'unfollow',
+    'browse_feed',
+    'search',
+    'get_channels',
+    'get_post_thread',
+    'get_notifications',
+    'get_profile',
+    'get_suggested_follows',
+  ]).describe('The SwarmFeed action to perform'),
+  content: z.string().optional().describe('Post or reply content'),
+  postId: z.string().optional().describe('Post ID for thread/reaction/reply actions'),
+  channelId: z.string().optional().describe('Channel ID for posting or browsing a channel feed'),
+  feedType: z.enum(['for_you', 'following', 'trending', 'channel']).optional().describe('Feed type for browse_feed'),
+  limit: z.number().optional().describe('Number of items to fetch'),
+  targetAgentId: z.string().optional().describe('Remote SwarmFeed agent ID for follow/unfollow/get_profile'),
+  query: z.string().optional().describe('Search query for search action'),
+  searchType: z.enum(['posts', 'agents', 'channels', 'hashtags']).optional().describe('Filter for search action'),
 })
 
 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(),
-    }
-  })
+function isAutonomousSocialPostSession(bctx: ToolBuildContext): boolean {
+  const session = bctx.resolveCurrentSession()
+  return Boolean(session?.heartbeatEnabled)
+}
 
-  return reg.apiKey
+async function getScopedAgent(agentId: string): Promise<Agent> {
+  return ensureSwarmFeedAgent(agentId)
+}
+
+function summarizePosts(posts: Array<{
+  id: string
+  agent?: { name?: string | null }
+  agentId: string
+  content: string
+  likeCount: number
+  replyCount: number
+  repostCount: number
+  createdAt: string
+}>): Array<Record<string, unknown>> {
+  return posts.map((post) => ({
+    id: post.id,
+    agentId: post.agentId,
+    agentName: post.agent?.name || null,
+    content: post.content.slice(0, 500),
+    likes: post.likeCount,
+    replies: post.replyCount,
+    reposts: post.repostCount,
+    createdAt: post.createdAt,
+  }))
 }
 
 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' })
+  const storedAgent = getAgent(agentId) as Agent | undefined
+  if (!storedAgent) return JSON.stringify({ error: 'Agent not found' })
+  if (!storedAgent.swarmfeedEnabled) return JSON.stringify({ error: 'SwarmFeed is not enabled for this agent' })
+
+  const autoPostPolicy = canAutoPostToSwarmFeed(storedAgent)
+  const autonomousSession = isAutonomousSocialPostSession(bctx)
 
   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, {
+        if (autonomousSession && !autoPostPolicy.allowed) return JSON.stringify({ error: autoPostPolicy.reason })
+        const agent = await getScopedAgent(agentId)
+        const post = await createPost(agent.swarmfeedApiKey!, {
           content: input.content.trim(),
           channelId: input.channelId,
         })
+        if (autonomousSession) markSwarmFeedAutoPost(agentId)
         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, {
+        if (autonomousSession && !autoPostPolicy.allowed) return JSON.stringify({ error: autoPostPolicy.reason })
+        const agent = await getScopedAgent(agentId)
+        const reply = await createPost(agent.swarmfeedApiKey!, {
           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 } })
+        if (autonomousSession) markSwarmFeedAutoPost(agentId)
+        return JSON.stringify({
+          success: true,
+          post: { id: reply.id, content: reply.content, parentId: input.postId, createdAt: reply.createdAt },
+        })
+      }
+
+      case 'quote_repost': {
+        if (!input.content?.trim()) return JSON.stringify({ error: 'content is required for quote_repost action' })
+        if (!input.postId) return JSON.stringify({ error: 'postId is required for quote_repost action' })
+        if (autonomousSession && !autoPostPolicy.allowed) return JSON.stringify({ error: autoPostPolicy.reason })
+        const agent = await getScopedAgent(agentId)
+        const post = await createPost(agent.swarmfeedApiKey!, {
+          content: input.content.trim(),
+          channelId: input.channelId,
+          quotedPostId: input.postId,
+        })
+        if (autonomousSession) markSwarmFeedAutoPost(agentId)
+        return JSON.stringify({ success: true, post: { id: post.id, content: post.content, quotedPostId: input.postId, createdAt: post.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)
+        const agent = await getScopedAgent(agentId)
+        await likePost(agent.swarmfeedApiKey!, input.postId)
         return JSON.stringify({ success: true, action: 'liked', postId: input.postId })
       }
 
+      case 'unlike': {
+        if (!input.postId) return JSON.stringify({ error: 'postId is required for unlike action' })
+        const agent = await getScopedAgent(agentId)
+        await unlikePost(agent.swarmfeedApiKey!, input.postId)
+        return JSON.stringify({ success: true, action: 'unliked', 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)
+        const agent = await getScopedAgent(agentId)
+        await repostPost(agent.swarmfeedApiKey!, input.postId)
         return JSON.stringify({ success: true, action: 'reposted', postId: input.postId })
       }
 
+      case 'unrepost': {
+        if (!input.postId) return JSON.stringify({ error: 'postId is required for unrepost action' })
+        const agent = await getScopedAgent(agentId)
+        await unrepostPost(agent.swarmfeedApiKey!, input.postId)
+        return JSON.stringify({ success: true, action: 'unreposted', postId: input.postId })
+      }
+
+      case 'bookmark': {
+        if (!input.postId) return JSON.stringify({ error: 'postId is required for bookmark action' })
+        const agent = await getScopedAgent(agentId)
+        await bookmarkPost(agent.swarmfeedApiKey!, input.postId)
+        return JSON.stringify({ success: true, action: 'bookmarked', postId: input.postId })
+      }
+
+      case 'unbookmark': {
+        if (!input.postId) return JSON.stringify({ error: 'postId is required for unbookmark action' })
+        const agent = await getScopedAgent(agentId)
+        await unbookmarkPost(agent.swarmfeedApiKey!, input.postId)
+        return JSON.stringify({ success: true, action: 'unbookmarked', postId: input.postId })
+      }
+
+      case 'follow': {
+        if (!input.targetAgentId) return JSON.stringify({ error: 'targetAgentId is required for follow action' })
+        const agent = await getScopedAgent(agentId)
+        await followAgent(agent.swarmfeedApiKey!, input.targetAgentId)
+        return JSON.stringify({ success: true, action: 'followed', targetAgentId: input.targetAgentId })
+      }
+
+      case 'unfollow': {
+        if (!input.targetAgentId) return JSON.stringify({ error: 'targetAgentId is required for unfollow action' })
+        const agent = await getScopedAgent(agentId)
+        await unfollowAgent(agent.swarmfeedApiKey!, input.targetAgentId)
+        return JSON.stringify({ success: true, action: 'unfollowed', targetAgentId: input.targetAgentId })
+      }
+
       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 })
+        const agent = feedType === 'following' || autonomousSession ? await getScopedAgent(agentId) : storedAgent
+        const result = await getFeed(feedType, { channelId: input.channelId, limit }, agent.swarmfeedApiKey || undefined)
+        return JSON.stringify({ posts: summarizePosts(result.posts), nextCursor: result.nextCursor })
+      }
+
+      case 'search': {
+        if (!input.query?.trim()) return JSON.stringify({ error: 'query is required for search action' })
+        const result = await searchSwarmFeed({
+          query: input.query.trim(),
+          type: input.searchType,
+          limit: input.limit || 10,
+        })
+        return JSON.stringify({
+          total: result.total,
+          posts: summarizePosts(result.posts || []),
+          agents: (result.agents || []).map((agent) => ({
+            id: agent.id,
+            name: agent.name,
+            framework: agent.framework || null,
+            followerCount: agent.followerCount,
+            bio: agent.bio || null,
+          })),
+          channels: (result.channels || []).map((channel) => ({
+            id: channel.id,
+            handle: channel.handle,
+            displayName: channel.displayName,
+            memberCount: channel.memberCount,
+          })),
+          hashtags: result.hashtags || [],
+        })
       }
 
       case 'get_channels': {
         const channels = await getChannels()
-        return JSON.stringify({ channels: channels.map((c) => ({ id: c.id, name: c.displayName, handle: c.handle })) })
+        return JSON.stringify({
+          channels: channels.map((channel) => ({
+            id: channel.id,
+            name: channel.displayName,
+            handle: channel.handle,
+            description: channel.description || null,
+            memberCount: channel.memberCount,
+          })),
+        })
+      }
+
+      case 'get_post_thread': {
+        if (!input.postId) return JSON.stringify({ error: 'postId is required for get_post_thread action' })
+        const [post, replies] = await Promise.all([
+          getPost(input.postId),
+          getPostReplies(input.postId, { limit: input.limit || 20 }),
+        ])
+        return JSON.stringify({
+          post,
+          replies: summarizePosts(replies.posts),
+          nextCursor: replies.nextCursor,
+        })
+      }
+
+      case 'get_notifications': {
+        const agent = await getScopedAgent(agentId)
+        const result = await getNotifications(agent.swarmfeedApiKey!, { limit: input.limit || 20 })
+        return JSON.stringify(result)
+      }
+
+      case 'get_profile': {
+        if (!input.targetAgentId) return JSON.stringify({ error: 'targetAgentId is required for get_profile action' })
+        return JSON.stringify(await getProfile(input.targetAgentId))
+      }
+
+      case 'get_suggested_follows': {
+        const agent = await getScopedAgent(agentId)
+        return JSON.stringify(await getSuggestedFollows(agent.swarmfeedApiKey!, input.limit || 5))
       }
 
       default:
@@ -121,13 +286,12 @@ async function executeSwarmFeed(input: SwarmFeedInput, bctx: ToolBuildContext):
     }
   } catch (err: unknown) {
     const message = err instanceof Error ? err.message : 'Unknown error'
-    log.error(TAG, `Action "${input.action}" failed for agent "${agent.name}": ${message}`)
+    log.error(TAG, `Action "${input.action}" failed for agent "${storedAgent.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 []
 
@@ -141,8 +305,7 @@ export function buildSwarmFeedTools(bctx: ToolBuildContext): StructuredToolInter
         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).',
+          'Actions include posting, replying, quote reposting, liking, bookmarking, following, searching, browsing feeds, reading threads, checking notifications, and viewing profiles.',
         schema: SWARMFEED_SCHEMA,
       },
     ),

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

@@ -526,6 +526,7 @@ function normalizeStoredRecordInner(
     if (!Array.isArray(agent.swarmfeedAutoPostChannels)) agent.swarmfeedAutoPostChannels = []
     if (typeof agent.swarmfeedApiKey !== 'string' && agent.swarmfeedApiKey !== null) agent.swarmfeedApiKey = null
     if (typeof agent.swarmfeedAgentId !== 'string' && agent.swarmfeedAgentId !== null) agent.swarmfeedAgentId = null
+    if (typeof agent.swarmfeedLastAutoPostAt !== 'number' && agent.swarmfeedLastAutoPostAt !== null) agent.swarmfeedLastAutoPostAt = null
     if (!agent.origin) agent.origin = 'swarmclaw'
     if (agent.swarmfeedHeartbeat === undefined) agent.swarmfeedHeartbeat = null
     // SwarmDock defaults

package/src/lib/server/swarmfeed-runtime.test.ts

@@ -0,0 +1,188 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { after, before, describe, it } from 'node:test'
+import type { Agent } from '@/types'
+
+const originalEnv = {
+  DATA_DIR: process.env.DATA_DIR,
+  WORKSPACE_DIR: process.env.WORKSPACE_DIR,
+  SWARMCLAW_BUILD_MODE: process.env.SWARMCLAW_BUILD_MODE,
+}
+
+let tempDir = ''
+let workspaceDir = ''
+let runtimeMod: typeof import('./swarmfeed-runtime')
+let agentRepoMod: typeof import('./agents/agent-repository')
+
+function makeAgent(overrides: Partial<Agent> = {}): Agent {
+  return {
+    id: 'agent-1',
+    name: 'Test Agent',
+    description: 'Social test agent',
+    systemPrompt: 'Be useful',
+    provider: 'openai',
+    model: 'gpt-4o-mini',
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    swarmfeedEnabled: true,
+    heartbeatEnabled: true,
+    swarmfeedAutoPostChannels: ['builders'],
+    swarmfeedHeartbeat: {
+      enabled: true,
+      browseFeed: true,
+      postFrequency: 'manual_only',
+      autoReply: false,
+      autoFollow: false,
+      channelsToMonitor: ['builders'],
+    },
+    ...overrides,
+  }
+}
+
+before(async () => {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-swarmfeed-runtime-'))
+  workspaceDir = path.join(tempDir, 'workspace')
+  fs.mkdirSync(workspaceDir, { recursive: true })
+  process.env.DATA_DIR = path.join(tempDir, 'data')
+  process.env.WORKSPACE_DIR = workspaceDir
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+
+  runtimeMod = await import('./swarmfeed-runtime')
+  agentRepoMod = await import('./agents/agent-repository')
+})
+
+after(() => {
+  if (originalEnv.DATA_DIR === undefined) delete process.env.DATA_DIR
+  else process.env.DATA_DIR = originalEnv.DATA_DIR
+  if (originalEnv.WORKSPACE_DIR === undefined) delete process.env.WORKSPACE_DIR
+  else process.env.WORKSPACE_DIR = originalEnv.WORKSPACE_DIR
+  if (originalEnv.SWARMCLAW_BUILD_MODE === undefined) delete process.env.SWARMCLAW_BUILD_MODE
+  else process.env.SWARMCLAW_BUILD_MODE = originalEnv.SWARMCLAW_BUILD_MODE
+  fs.rmSync(tempDir, { recursive: true, force: true })
+})
+
+describe('buildSwarmFeedHeartbeatGuidance', () => {
+  it('returns empty string when SwarmFeed social heartbeat is disabled', () => {
+    const guidance = runtimeMod.buildSwarmFeedHeartbeatGuidance(
+      makeAgent({ swarmfeedEnabled: false }),
+    )
+    assert.equal(guidance, '')
+  })
+
+  it('explains that social automation is inactive when the main heartbeat is disabled', () => {
+    const guidance = runtimeMod.buildSwarmFeedHeartbeatGuidance(
+      makeAgent({ heartbeatEnabled: false }),
+    )
+    assert.match(guidance, /currently inactive/i)
+    assert.match(guidance, /heartbeat is disabled/i)
+  })
+
+  it('includes the manual-only guardrail for autonomous posting', () => {
+    const guidance = runtimeMod.buildSwarmFeedHeartbeatGuidance(
+      makeAgent({
+        swarmfeedHeartbeat: {
+          enabled: true,
+          browseFeed: false,
+          postFrequency: 'manual_only',
+          autoReply: false,
+          autoFollow: false,
+          channelsToMonitor: [],
+        },
+      }),
+    )
+    assert.match(guidance, /manual only/i)
+    assert.match(guidance, /Do not author new SwarmFeed posts or replies/i)
+  })
+
+  it('mentions the recent-post limit for daily posting', () => {
+    const guidance = runtimeMod.buildSwarmFeedHeartbeatGuidance(
+      makeAgent({
+        swarmfeedLastAutoPostAt: Date.now() - 60_000,
+        swarmfeedHeartbeat: {
+          enabled: true,
+          browseFeed: true,
+          postFrequency: 'daily',
+          autoReply: true,
+          autoFollow: true,
+          channelsToMonitor: ['builders'],
+        },
+      }),
+    )
+    assert.match(guidance, /daily auto-post already happened/i)
+  })
+
+  it('describes the on-task-completion policy explicitly', () => {
+    const guidance = runtimeMod.buildSwarmFeedHeartbeatGuidance(
+      makeAgent({
+        swarmfeedHeartbeat: {
+          enabled: true,
+          browseFeed: true,
+          postFrequency: 'on_task_completion',
+          autoReply: false,
+          autoFollow: false,
+          channelsToMonitor: ['builders'],
+        },
+      }),
+    )
+    assert.match(guidance, /on task completion/i)
+    assert.match(guidance, /completed task/i)
+  })
+})
+
+describe('canAutoPostToSwarmFeed', () => {
+  it('blocks autonomous posting when manual_only is configured', () => {
+    const result = runtimeMod.canAutoPostToSwarmFeed(makeAgent())
+    assert.equal(result.allowed, false)
+    assert.match(result.reason || '', /manual_only/i)
+  })
+
+  it('blocks autonomous posting after a recent daily post', () => {
+    const result = runtimeMod.canAutoPostToSwarmFeed(
+      makeAgent({
+        swarmfeedLastAutoPostAt: Date.now() - 60_000,
+        swarmfeedHeartbeat: {
+          enabled: true,
+          browseFeed: true,
+          postFrequency: 'daily',
+          autoReply: false,
+          autoFollow: false,
+          channelsToMonitor: [],
+        },
+      }),
+    )
+    assert.equal(result.allowed, false)
+    assert.match(result.reason || '', /daily autonomous SwarmFeed post/i)
+  })
+
+  it('allows daily posting when the last automatic post is older than 24 hours', () => {
+    const result = runtimeMod.canAutoPostToSwarmFeed(
+      makeAgent({
+        swarmfeedLastAutoPostAt: Date.now() - (25 * 60 * 60 * 1000),
+        swarmfeedHeartbeat: {
+          enabled: true,
+          browseFeed: true,
+          postFrequency: 'daily',
+          autoReply: false,
+          autoFollow: false,
+          channelsToMonitor: [],
+        },
+      }),
+    )
+    assert.equal(result.allowed, true)
+  })
+})
+
+describe('markSwarmFeedAutoPost', () => {
+  it('persists the last auto-post timestamp on the agent record', () => {
+    const agent = makeAgent({ id: 'agent-mark-post' })
+    agentRepoMod.saveAgent(agent.id, agent)
+
+    runtimeMod.markSwarmFeedAutoPost(agent.id)
+
+    const updated = agentRepoMod.getAgent(agent.id)
+    assert.equal(typeof updated?.swarmfeedLastAutoPostAt, 'number')
+    assert.ok((updated?.swarmfeedLastAutoPostAt || 0) >= agent.createdAt)
+  })
+})