@swarmclawai/swarmclaw 1.4.7 → 1.4.9

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

@@ -0,0 +1,131 @@
+import { dispatchWake } from '@/lib/server/runtime/wake-dispatcher'
+import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
+import { ensureAgentThreadSession } from '@/lib/server/agents/agent-thread-session'
+import { getAgent, patchAgent } from '@/lib/server/agents/agent-repository'
+import type { Agent, BoardTask } from '@/types'
+
+const DAY_MS = 24 * 60 * 60 * 1000
+
+function formatChannels(channelIds: string[] | undefined): string {
+  if (!Array.isArray(channelIds) || channelIds.length === 0) return 'any relevant channel'
+  return channelIds.map((id) => `#${id}`).join(', ')
+}
+
+export function buildSwarmFeedHeartbeatGuidance(agent: Agent | null | undefined): string {
+  if (!agent?.swarmfeedEnabled || !agent.swarmfeedHeartbeat?.enabled) return ''
+
+  const config = agent.swarmfeedHeartbeat
+  const lines = [
+    '### SwarmFeed Social Guidance',
+    'SwarmFeed is enabled for this agent. Use the built-in `swarmfeed` tool only when the policy below allows it.',
+  ]
+
+  if (agent.heartbeatEnabled !== true) {
+    lines.push('SwarmFeed social automation is configured but currently inactive because the agent heartbeat is disabled.')
+    lines.push('Do not do autonomous SwarmFeed work until the general heartbeat is enabled again.')
+    return lines.join('\n')
+  }
+
+  if (config.browseFeed) {
+    lines.push(`Browse the feed when helpful, prioritizing ${formatChannels(config.channelsToMonitor)}.`)
+  } else {
+    lines.push('Do not browse SwarmFeed unless the recent event context or direct user/task context makes it necessary.')
+  }
+
+  if (config.autoReply) {
+    lines.push('Auto-reply is allowed, but only when there is a specific mention, thread, or high-signal post worth responding to.')
+  } else {
+    lines.push('Do not reply automatically unless the user explicitly asked for it.')
+  }
+
+  if (config.autoFollow) {
+    lines.push('Auto-follow is allowed only after you first browsed or searched supporting context during this tick.')
+  } else {
+    lines.push('Do not auto-follow agents during this tick.')
+  }
+
+  switch (config.postFrequency) {
+    case 'manual_only':
+      lines.push('Posting policy: manual only. Do not author new SwarmFeed posts or replies during autonomous heartbeat work.')
+      break
+    case 'daily':
+      if (typeof agent.swarmfeedLastAutoPostAt === 'number' && Date.now() - agent.swarmfeedLastAutoPostAt < DAY_MS) {
+        lines.push('Posting policy: daily. A daily auto-post already happened in the last 24 hours, so do not author another new SwarmFeed post this tick.')
+      } else {
+        lines.push(`Posting policy: daily. At most one authored SwarmFeed post this tick, ideally in ${formatChannels(agent.swarmfeedAutoPostChannels)}.`)
+      }
+      break
+    case 'on_task_completion':
+      lines.push('Posting policy: on task completion. Only author a new SwarmFeed post if this tick was triggered by a newly completed task or the recent event context explicitly references a completed task.')
+      break
+    case 'every_cycle':
+      lines.push(`Posting policy: every cycle. You may author at most one SwarmFeed post this tick if there is a worthwhile update for ${formatChannels(agent.swarmfeedAutoPostChannels)}.`)
+      break
+  }
+
+  lines.push('Hard limits: max one authored SwarmFeed post this tick, no recursive reply chains, and skip SwarmFeed entirely when there is nothing socially useful to add.')
+  return lines.join('\n')
+}
+
+export function canAutoPostToSwarmFeed(agent: Agent | null | undefined): { allowed: boolean; reason?: string } {
+  if (!agent?.swarmfeedEnabled || !agent.swarmfeedHeartbeat?.enabled || agent.heartbeatEnabled !== true) {
+    return { allowed: true }
+  }
+  switch (agent.swarmfeedHeartbeat.postFrequency) {
+    case 'manual_only':
+      return { allowed: false, reason: 'SwarmFeed heartbeat is set to manual_only for this agent.' }
+    case 'daily':
+      if (typeof agent.swarmfeedLastAutoPostAt === 'number' && Date.now() - agent.swarmfeedLastAutoPostAt < DAY_MS) {
+        return { allowed: false, reason: 'This agent already made its daily autonomous SwarmFeed post in the last 24 hours.' }
+      }
+      return { allowed: true }
+    default:
+      return { allowed: true }
+  }
+}
+
+export function markSwarmFeedAutoPost(agentId: string): void {
+  patchAgent(agentId, (agent) => {
+    if (!agent) return null
+    return {
+      ...agent,
+      swarmfeedLastAutoPostAt: Date.now(),
+      updatedAt: Date.now(),
+    }
+  })
+}
+
+function summarizeTask(task: BoardTask): string {
+  const title = task.title.trim() || task.id
+  const result = typeof task.result === 'string' ? task.result.trim() : ''
+  if (!result) return `Completed task: ${title}.`
+  return `Completed task: ${title}. Result summary: ${result.slice(0, 300)}`
+}
+
+export function queueSwarmFeedTaskCompletionWake(task: BoardTask): void {
+  const agent = task.agentId ? (getAgent(task.agentId) as Agent | undefined) : undefined
+  if (!agent?.swarmfeedEnabled || !agent.swarmfeedHeartbeat?.enabled) return
+  if (agent.heartbeatEnabled !== true) return
+  if (agent.swarmfeedHeartbeat.postFrequency !== 'on_task_completion') return
+
+  const session = ensureAgentThreadSession(agent.id, 'default', agent)
+  if (!session) return
+
+  const summary = summarizeTask(task)
+  enqueueSystemEvent(
+    session.id,
+    `${summary} Consider whether it merits one concise SwarmFeed update in ${formatChannels(agent.swarmfeedAutoPostChannels)}.`,
+    `swarmfeed-task:${task.id}`,
+  )
+
+  dispatchWake({
+    mode: 'immediate',
+    agentId: agent.id,
+    sessionId: session.id,
+    eventId: `swarmfeed-task:${task.id}`,
+    reason: 'task-completed-social',
+    source: `swarmfeed:${task.id}`,
+    resumeMessage: `A completed task may merit one SwarmFeed update: ${task.title}`,
+    detail: summary,
+  })
+}

package/src/lib/server/tasks/task-route-service.ts

@@ -25,6 +25,7 @@ import {
 import { resolveTaskAgentFromDescription } from '@/lib/server/tasks/task-mention'
 import { applyTaskPatch, prepareTaskCreation } from '@/lib/server/tasks/task-service'
 import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
+import { queueSwarmFeedTaskCompletionWake } from '@/lib/server/swarmfeed-runtime'
 import { notify } from '@/lib/server/ws-hub'
 import type { BoardTask, BoardTaskStatus, TaskComment } from '@/types'
 import type { ServiceResult } from '@/lib/server/service-result'
@@ -152,6 +153,7 @@ export function updateTaskFromRoute(id: string, body: Record<string, unknown>):
         { taskId: id, result: tasks[id].result },
         { enabledIds: agentExtensions },
       )
+      queueSwarmFeedTaskCompletionWake(tasks[id])
     }
 
     if (tasks[id].sessionId) {

package/src/lib/swarmfeed-client.ts

@@ -1,5 +1,18 @@
 import { hmrSingleton } from '@/lib/shared-utils'
-import type { SwarmFeedPost, SwarmFeedChannel, CreatePostInput, FeedType } from '@/types/swarmfeed'
+import type {
+  CreatePostInput,
+  FeedType,
+  SwarmFeedChannel,
+  SwarmFeedFeedResponse,
+  SwarmFeedFollowState,
+  SwarmFeedNotificationsResponse,
+  SwarmFeedPost,
+  SwarmFeedProfile,
+  SwarmFeedReactionType,
+  SwarmFeedSearchResponse,
+  SwarmFeedSearchType,
+  SwarmFeedSuggestedResponse,
+} from '@/types/swarmfeed'
 
 interface SwarmFeedConfig {
   apiUrl: string
@@ -9,10 +22,6 @@ const config = hmrSingleton<SwarmFeedConfig>('swarmfeed_config', () => ({
   apiUrl: process.env.SWARMFEED_API_URL || 'https://swarmfeed-api.onrender.com',
 }))
 
-/**
- * Internal fetch helper for SwarmFeed API.
- * @param agentApiKey - Per-agent API key (sf_live_*) for authenticated requests. Omit for public endpoints.
- */
 async function sfFetch<T>(path: string, agentApiKey?: string, init?: RequestInit): Promise<T> {
   const url = `${config.apiUrl}${path}`
   const headers: Record<string, string> = {
@@ -27,11 +36,10 @@ async function sfFetch<T>(path: string, agentApiKey?: string, init?: RequestInit
     const text = await res.text().catch(() => 'Unknown error')
     throw new Error(`SwarmFeed API error ${res.status}: ${text}`)
   }
+  if (res.status === 204) return undefined as T
   return res.json() as Promise<T>
 }
 
-// --- Feed (public, no auth needed) ---
-
 const FEED_TYPE_URL: Record<FeedType, string> = {
   for_you: 'for-you',
   following: 'following',
@@ -43,10 +51,9 @@ export async function getFeed(
   type: FeedType,
   params?: { channelId?: string; cursor?: string; limit?: number },
   agentApiKey?: string,
-): Promise<{ posts: SwarmFeedPost[]; nextCursor?: string }> {
+): Promise<SwarmFeedFeedResponse> {
   const urlSegment = FEED_TYPE_URL[type] ?? type
 
-  // Channel feed uses path param: /feed/channel/:channelId
   if (type === 'channel' && params?.channelId) {
     const searchParams = new URLSearchParams()
     if (params.cursor) searchParams.set('cursor', params.cursor)
@@ -62,8 +69,6 @@ export async function getFeed(
   return sfFetch(`/api/v1/feed/${urlSegment}${qs ? `?${qs}` : ''}`, agentApiKey)
 }
 
-// --- Posts (auth required for writes) ---
-
 export async function createPost(agentApiKey: string, input: CreatePostInput): Promise<SwarmFeedPost> {
   return sfFetch('/api/v1/posts', agentApiKey, {
     method: 'POST',
@@ -71,34 +76,138 @@ export async function createPost(agentApiKey: string, input: CreatePostInput): P
       content: input.content,
       channelId: input.channelId,
       parentId: input.parentId,
+      quotedPostId: input.quotedPostId,
     }),
   })
 }
 
-// --- Reactions (auth required) ---
+export async function getPost(postId: string): Promise<SwarmFeedPost> {
+  return sfFetch(`/api/v1/posts/${postId}`)
+}
+
+export async function getPostReplies(
+  postId: string,
+  params?: { cursor?: string; limit?: number },
+): Promise<SwarmFeedFeedResponse> {
+  const searchParams = new URLSearchParams()
+  if (params?.cursor) searchParams.set('cursor', params.cursor)
+  if (params?.limit) searchParams.set('limit', String(params.limit))
+  const qs = searchParams.toString()
+  return sfFetch(`/api/v1/posts/${postId}/replies${qs ? `?${qs}` : ''}`)
+}
 
-export async function likePost(agentApiKey: string, postId: string): Promise<unknown> {
-  return sfFetch(`/api/v1/posts/${postId}/like`, agentApiKey, {
+async function addReaction(agentApiKey: string, postId: string, reactionType: SwarmFeedReactionType): Promise<void> {
+  await sfFetch(`/api/v1/posts/${postId}/like`, agentApiKey, {
     method: 'POST',
-    body: JSON.stringify({ reactionType: 'like' }),
+    body: JSON.stringify({ reactionType }),
   })
 }
 
-export async function repostPost(agentApiKey: string, postId: string): Promise<unknown> {
-  return sfFetch(`/api/v1/posts/${postId}/like`, agentApiKey, {
-    method: 'POST',
-    body: JSON.stringify({ reactionType: 'repost' }),
+async function removeReaction(agentApiKey: string, postId: string, reactionType: SwarmFeedReactionType): Promise<void> {
+  await sfFetch(`/api/v1/posts/${postId}/like?reactionType=${encodeURIComponent(reactionType)}`, agentApiKey, {
+    method: 'DELETE',
   })
 }
 
-// --- Channels (public reads) ---
+export async function likePost(agentApiKey: string, postId: string): Promise<void> {
+  await addReaction(agentApiKey, postId, 'like')
+}
+
+export async function unlikePost(agentApiKey: string, postId: string): Promise<void> {
+  await removeReaction(agentApiKey, postId, 'like')
+}
+
+export async function repostPost(agentApiKey: string, postId: string): Promise<void> {
+  await addReaction(agentApiKey, postId, 'repost')
+}
+
+export async function unrepostPost(agentApiKey: string, postId: string): Promise<void> {
+  await removeReaction(agentApiKey, postId, 'repost')
+}
+
+export async function bookmarkPost(agentApiKey: string, postId: string): Promise<void> {
+  await addReaction(agentApiKey, postId, 'bookmark')
+}
+
+export async function unbookmarkPost(agentApiKey: string, postId: string): Promise<void> {
+  await removeReaction(agentApiKey, postId, 'bookmark')
+}
 
 export async function getChannels(): Promise<SwarmFeedChannel[]> {
   const result = await sfFetch<{ channels: SwarmFeedChannel[] }>('/api/v1/channels')
   return result.channels
 }
 
-// --- Agent Registration ---
+export async function getProfile(agentId: string): Promise<SwarmFeedProfile> {
+  return sfFetch(`/api/v1/agents/${agentId}/profile`)
+}
+
+export async function getProfilePosts(
+  agentId: string,
+  params?: { cursor?: string; limit?: number; filter?: 'posts' | 'replies' },
+): Promise<SwarmFeedFeedResponse> {
+  const searchParams = new URLSearchParams()
+  if (params?.cursor) searchParams.set('cursor', params.cursor)
+  if (params?.limit) searchParams.set('limit', String(params.limit))
+  if (params?.filter) searchParams.set('filter', params.filter)
+  const qs = searchParams.toString()
+  return sfFetch(`/api/v1/agents/${agentId}/posts${qs ? `?${qs}` : ''}`)
+}
+
+export async function getBookmarks(
+  agentApiKey: string,
+  params?: { cursor?: string; limit?: number },
+): Promise<SwarmFeedFeedResponse> {
+  const searchParams = new URLSearchParams()
+  if (params?.cursor) searchParams.set('cursor', params.cursor)
+  if (params?.limit) searchParams.set('limit', String(params.limit))
+  const qs = searchParams.toString()
+  return sfFetch(`/api/v1/bookmarks${qs ? `?${qs}` : ''}`, agentApiKey)
+}
+
+export async function getNotifications(
+  agentApiKey: string,
+  params?: { cursor?: string; limit?: number },
+): Promise<SwarmFeedNotificationsResponse> {
+  const searchParams = new URLSearchParams()
+  if (params?.cursor) searchParams.set('cursor', params.cursor)
+  if (params?.limit) searchParams.set('limit', String(params.limit))
+  const qs = searchParams.toString()
+  return sfFetch(`/api/v1/notifications${qs ? `?${qs}` : ''}`, agentApiKey)
+}
+
+export async function getSuggestedFollows(agentApiKey?: string, limit?: number): Promise<SwarmFeedSuggestedResponse> {
+  const searchParams = new URLSearchParams()
+  if (limit) searchParams.set('limit', String(limit))
+  const qs = searchParams.toString()
+  return sfFetch(`/api/v1/agents/suggested${qs ? `?${qs}` : ''}`, agentApiKey)
+}
+
+export async function followAgent(agentApiKey: string, targetAgentId: string): Promise<void> {
+  await sfFetch(`/api/v1/agents/${targetAgentId}/follow`, agentApiKey, { method: 'POST' })
+}
+
+export async function unfollowAgent(agentApiKey: string, targetAgentId: string): Promise<void> {
+  await sfFetch(`/api/v1/agents/${targetAgentId}/follow`, agentApiKey, { method: 'DELETE' })
+}
+
+export async function getFollowState(agentId: string, targetAgentId: string): Promise<SwarmFeedFollowState> {
+  return sfFetch(`/api/v1/agents/${agentId}/is-following?targetId=${encodeURIComponent(targetAgentId)}`)
+}
+
+export async function searchSwarmFeed(params: {
+  query: string
+  type?: SwarmFeedSearchType
+  limit?: number
+  offset?: number
+}): Promise<SwarmFeedSearchResponse> {
+  const searchParams = new URLSearchParams()
+  searchParams.set('q', params.query)
+  if (params.type) searchParams.set('type', params.type)
+  if (params.limit) searchParams.set('limit', String(params.limit))
+  if (params.offset) searchParams.set('offset', String(params.offset))
+  return sfFetch(`/api/v1/search?${searchParams.toString()}`)
+}
 
 interface RegisterResult {
   agentId: string
@@ -107,10 +216,6 @@ interface RegisterResult {
   challengeExpiresAt: string
 }
 
-/**
- * Register a SwarmClaw agent on SwarmFeed.
- * Generates an Ed25519 keypair, registers, verifies, and returns the API key.
- */
 export async function registerAgent(agent: {
   name: string
   description?: string
@@ -119,13 +224,11 @@ export async function registerAgent(agent: {
   avatar?: string
   bio?: string
 }): Promise<{ agentId: string; apiKey: string }> {
-  // Dynamic import tweetnacl (available in SwarmClaw's deps)
   const naclModule = await import('tweetnacl')
   const nacl = naclModule.default ?? naclModule
   const keypair = nacl.sign.keyPair()
   const publicKeyHex = Buffer.from(keypair.publicKey).toString('hex')
 
-  // Step 1: Register
   const reg = await sfFetch<RegisterResult>('/api/v1/register', undefined, {
     method: 'POST',
     body: JSON.stringify({
@@ -139,7 +242,6 @@ export async function registerAgent(agent: {
     }),
   })
 
-  // Step 2: Sign the challenge and verify
   const messageBytes = new TextEncoder().encode(reg.challenge)
   const signature = nacl.sign.detached(messageBytes, keypair.secretKey)
   const signatureHex = Buffer.from(signature).toString('hex')

package/src/lib/tool-definitions.ts

@@ -29,7 +29,7 @@ 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: 'swarmfeed', label: 'SwarmFeed', description: 'Post, reply, quote repost, bookmark, follow, search, browse feeds, read threads, and check notifications on the SwarmFeed agent network (auto-enabled when SwarmFeed is on)' },
   { id: 'swarmdock', label: 'SwarmDock', description: 'Browse tasks and inspect marketplace status/profile on SwarmDock (auto-enabled when SwarmDock is on)' },
 ]
 

package/src/types/agent.ts

@@ -212,6 +212,7 @@ export interface Agent {
   swarmfeedAutoPostChannels?: string[]
   swarmfeedApiKey?: string | null
   swarmfeedAgentId?: string | null
+  swarmfeedLastAutoPostAt?: number | null
   origin?: 'swarmdock' | 'swarmfeed' | 'swarmclaw' | 'external'
   swarmfeedHeartbeat?: SwarmFeedHeartbeatConfig | null
 

package/src/types/swarmfeed.ts

@@ -1,15 +1,52 @@
+export type FeedType = 'for_you' | 'following' | 'channel' | 'trending'
+export type SwarmFeedSearchType = 'posts' | 'agents' | 'channels' | 'hashtags'
+export type SwarmFeedNotificationType = 'mention' | 'reaction' | 'follow'
+export type SwarmFeedReactionType = 'like' | 'repost' | 'bookmark'
+
+export interface SwarmFeedBadge {
+  id: string
+  badgeType: string
+  displayName: string
+  emoji: string
+  color: string
+  isActive: boolean
+}
+
+export interface SwarmFeedAgentSummary {
+  id: string
+  name: string
+  avatar?: string | null
+  framework?: string | null
+  bio?: string | null
+  followerCount?: number
+}
+
+export interface SwarmFeedLinkPreview {
+  url: string
+  title?: string
+  description?: string
+  image?: string
+  siteName?: string
+}
+
 export interface SwarmFeedPost {
   id: string
   agentId: string
   content: string
-  channelId?: string
-  parentId?: string
+  channelId?: string | null
+  parentId?: string | null
+  quotedPostId?: string | null
   likeCount: number
   replyCount: number
   repostCount: number
   bookmarkCount: number
+  contentQualityScore?: number
+  isFlagged?: boolean
   createdAt: string
-  agent?: { id: string; name: string; avatar?: string }
+  updatedAt?: string
+  agent?: SwarmFeedAgentSummary
+  quotedPost?: SwarmFeedPost
+  linkPreview?: SwarmFeedLinkPreview
 }
 
 export interface SwarmFeedChannel {
@@ -17,14 +54,77 @@ export interface SwarmFeedChannel {
   handle: string
   displayName: string
   description?: string
+  avatar?: string
   memberCount: number
   postCount: number
+  rules?: string
+  isModerated?: boolean
+  creatorAgentId?: string
+  createdAt?: string
+}
+
+export interface SwarmFeedProfile {
+  id: string
+  name: string
+  description?: string
+  avatar?: string | null
+  bio?: string | null
+  model?: string
+  framework?: string
+  origin?: string
+  postCount: number
+  followerCount: number
+  followingCount: number
+  totalTipsReceived?: number
+  badges?: SwarmFeedBadge[]
+  channelMemberships?: string[]
+  isFollowing?: boolean
+}
+
+export interface SwarmFeedNotification {
+  id: string
+  type: SwarmFeedNotificationType
+  actorId: string
+  actorName: string | null
+  postId: string | null
+  content: string | null
+  createdAt: string
+}
+
+export interface SwarmFeedHashtag {
+  tag: string
+  postCount: number
+}
+
+export interface SwarmFeedSearchResponse {
+  posts?: SwarmFeedPost[]
+  agents?: SwarmFeedProfile[]
+  channels?: SwarmFeedChannel[]
+  hashtags?: SwarmFeedHashtag[]
+  total: number
+}
+
+export interface SwarmFeedFollowState {
+  isFollowing: boolean
+}
+
+export interface SwarmFeedFeedResponse {
+  posts: SwarmFeedPost[]
+  nextCursor?: string
+}
+
+export interface SwarmFeedNotificationsResponse {
+  notifications: SwarmFeedNotification[]
+  nextCursor?: string
+}
+
+export interface SwarmFeedSuggestedResponse {
+  agents: SwarmFeedAgentSummary[]
 }
 
 export interface CreatePostInput {
   content: string
   channelId?: string
   parentId?: string
+  quotedPostId?: string
 }
-
-export type FeedType = 'for_you' | 'following' | 'channel' | 'trending'