@swarmclawai/swarmclaw 1.3.6 → 1.4.0

package/src/lib/server/working-state/service.ts

@@ -244,15 +244,46 @@ export function syncWorkingStateFromMainLoopState(input: {
   status?: WorkingStateStatus | null
   nextAction?: string | null
   planSteps?: string[]
+  completedPlanSteps?: string[]
   blockers?: Array<{ summary: string; kind?: WorkingBlocker['kind'] | null }>
   facts?: string[]
 }): SessionWorkingState {
-  const planSteps = Array.isArray(input.planSteps)
-    ? input.planSteps.map((step, index) => ({
-      text: step,
-      status: index === 0 && input.status !== 'completed' ? 'active' : (input.status === 'completed' ? 'resolved' : 'resolved'),
-    } satisfies WorkingPlanStepPatch))
-    : undefined
+  const planSteps = (() => {
+    const activeSteps = Array.isArray(input.planSteps)
+      ? input.planSteps
+        .map((step) => cleanText(step, 240))
+        .filter((step): step is string => Boolean(step))
+      : []
+    const completedSteps = Array.isArray(input.completedPlanSteps)
+      ? input.completedPlanSteps
+        .map((step) => cleanText(step, 240))
+        .filter((step): step is string => Boolean(step))
+      : []
+    const out: WorkingPlanStepPatch[] = []
+    const seen = new Set<string>()
+
+    for (const [index, step] of activeSteps.entries()) {
+      const key = step.toLowerCase()
+      if (seen.has(key)) continue
+      seen.add(key)
+      out.push({
+        text: step,
+        status: index === 0 && input.status !== 'completed' ? 'active' : 'resolved',
+      } satisfies WorkingPlanStepPatch)
+    }
+
+    for (const step of completedSteps) {
+      const key = step.toLowerCase()
+      if (seen.has(key)) continue
+      seen.add(key)
+      out.push({
+        text: step,
+        status: 'resolved',
+      } satisfies WorkingPlanStepPatch)
+    }
+
+    return out.length > 0 ? out : undefined
+  })()
   return applyWorkingStatePatch(input.sessionId, {
     objective: cleanMultiline(input.goal, 900) || undefined,
     summary: cleanMultiline(input.summary, 600) || undefined,

package/src/lib/swarmfeed-client.ts

@@ -0,0 +1,157 @@
+import { hmrSingleton } from '@/lib/shared-utils'
+import type { SwarmFeedPost, SwarmFeedChannel, CreatePostInput, FeedType } from '@/types/swarmfeed'
+
+interface SwarmFeedConfig {
+  apiUrl: string
+}
+
+const config = hmrSingleton<SwarmFeedConfig>('swarmfeed_config', () => ({
+  apiUrl: process.env.SWARMFEED_API_URL || 'http://localhost:3700',
+}))
+
+/**
+ * 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> = {
+    'Content-Type': 'application/json',
+    ...(agentApiKey ? { Authorization: `Bearer ${agentApiKey}` } : {}),
+  }
+  const res = await fetch(url, {
+    ...init,
+    headers: { ...headers, ...(init?.headers as Record<string, string> | undefined) },
+  })
+  if (!res.ok) {
+    const text = await res.text().catch(() => 'Unknown error')
+    throw new Error(`SwarmFeed API error ${res.status}: ${text}`)
+  }
+  return res.json() as Promise<T>
+}
+
+// --- Feed (public, no auth needed) ---
+
+const FEED_TYPE_URL: Record<FeedType, string> = {
+  for_you: 'for-you',
+  following: 'following',
+  channel: 'channel',
+  trending: 'trending',
+}
+
+export async function getFeed(
+  type: FeedType,
+  params?: { channelId?: string; cursor?: string; limit?: number },
+  agentApiKey?: string,
+): Promise<{ posts: SwarmFeedPost[]; nextCursor?: string }> {
+  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)
+    if (params.limit) searchParams.set('limit', String(params.limit))
+    const qs = searchParams.toString()
+    return sfFetch(`/api/v1/feed/channel/${params.channelId}${qs ? `?${qs}` : ''}`, agentApiKey)
+  }
+
+  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/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',
+    body: JSON.stringify({
+      content: input.content,
+      channelId: input.channelId,
+      parentId: input.parentId,
+    }),
+  })
+}
+
+// --- Reactions (auth required) ---
+
+export async function likePost(agentApiKey: string, postId: string): Promise<unknown> {
+  return sfFetch(`/api/v1/posts/${postId}/like`, agentApiKey, {
+    method: 'POST',
+    body: JSON.stringify({ reactionType: 'like' }),
+  })
+}
+
+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' }),
+  })
+}
+
+// --- Channels (public reads) ---
+
+export async function getChannels(): Promise<SwarmFeedChannel[]> {
+  const result = await sfFetch<{ channels: SwarmFeedChannel[] }>('/api/v1/channels')
+  return result.channels
+}
+
+// --- Agent Registration ---
+
+interface RegisterResult {
+  agentId: string
+  apiKey: string
+  challenge: string
+  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
+  framework?: string
+  model?: string
+  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({
+      publicKey: publicKeyHex,
+      name: agent.name,
+      description: agent.description,
+      framework: agent.framework,
+      modelName: agent.model,
+      avatarUrl: agent.avatar,
+      bio: agent.bio,
+    }),
+  })
+
+  // 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')
+
+  await sfFetch('/api/v1/register/verify', undefined, {
+    method: 'POST',
+    body: JSON.stringify({
+      publicKey: publicKeyHex,
+      challenge: reg.challenge,
+      signature: signatureHex,
+    }),
+  })
+
+  return { agentId: reg.agentId, apiKey: reg.apiKey }
+}

package/src/lib/validation/schemas.ts

@@ -147,7 +147,7 @@ export const ConnectorCreateSchema = z.object({
 export const ExternalAgentRegisterSchema = z.object({
   id: z.string().optional(),
   name: z.string().min(1, 'External agent name is required'),
-  sourceType: z.enum(['codex', 'claude', 'opencode', 'openclaw', 'custom']).default('custom'),
+  sourceType: z.enum(['codex', 'claude', 'opencode', 'openclaw', 'custom', 'a2a']).default('custom'),
   status: z.enum(['online', 'idle', 'offline', 'stale']).optional().default('online'),
   provider: z.string().nullable().optional().default(null),
   model: z.string().nullable().optional().default(null),

package/src/stores/slices/data-slice.ts

@@ -159,6 +159,7 @@ export const createDataSlice: StateCreator<AppState, [], [], DataSlice> = (set,
     const notifications = get().notifications.map((n) =>
       n.id === id ? { ...n, read: true } : n,
     )
+    invalidateFingerprint('notifications')
     set({
       notifications,
       unreadNotificationCount: notifications.filter((n) => !n.read).length,
@@ -174,6 +175,7 @@ export const createDataSlice: StateCreator<AppState, [], [], DataSlice> = (set,
     if (!unreadIds.length) return
     const originalNotifications = get().notifications
     const notifications = originalNotifications.map((n) => ({ ...n, read: true }))
+    invalidateFingerprint('notifications')
     set({ notifications, unreadNotificationCount: 0 })
     try {
       await Promise.all(unreadIds.map((id) => api('PUT', `/notifications/${id}`, { read: true })))
@@ -185,6 +187,7 @@ export const createDataSlice: StateCreator<AppState, [], [], DataSlice> = (set,
   clearReadNotifications: async () => {
     const original = get().notifications
     const kept = original.filter((n) => !n.read)
+    invalidateFingerprint('notifications')
     set({ notifications: kept, unreadNotificationCount: kept.length })
     try {
       await api('DELETE', '/notifications')

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

@@ -4,6 +4,7 @@ import { create } from 'zustand'
 import type { PendingExecApproval, ExecApprovalDecision } from '@/types'
 import { api } from '@/lib/app/api-client'
 import { errorMessage } from '@/lib/shared-utils'
+import { setIfChanged, invalidateFingerprint } from './set-if-changed'
 
 interface ApprovalState {
   approvals: Record<string, PendingExecApproval>
@@ -20,10 +21,12 @@ export const useApprovalStore = create<ApprovalState>((set) => ({
   resolvedIds: new Set<string>(),
 
   addApproval: (approval) => {
+    invalidateFingerprint('approvals')
     set((s) => ({ approvals: { ...s.approvals, [approval.id]: approval } }))
   },
 
   removeApproval: (id) => {
+    invalidateFingerprint('approvals')
     set((s) => {
       const next = { ...s.approvals }
       delete next[id]
@@ -91,7 +94,7 @@ export const useApprovalStore = create<ApprovalState>((set) => ({
       const result = await api<PendingExecApproval[]>('GET', '/openclaw/approvals')
       const approvals: Record<string, PendingExecApproval> = {}
       for (const a of result) approvals[a.id] = a
-      set({ approvals, resolvedIds: new Set<string>() })
+      setIfChanged<ApprovalState>(set, 'approvals', approvals)
     } catch {
       // ignore — gateway may be offline
     }

package/src/types/agent.ts

@@ -3,6 +3,17 @@ import type { SessionResetMode, IdentityContinuityState } from './session'
 import type { SkillAllowlistMode } from './skill'
 import type { DreamConfig } from './dream'
 
+// --- SwarmFeed Heartbeat ---
+
+export interface SwarmFeedHeartbeatConfig {
+  enabled: boolean
+  browseFeed: boolean
+  postFrequency: 'every_cycle' | 'daily' | 'on_task_completion' | 'manual_only'
+  autoReply: boolean
+  autoFollow: boolean
+  channelsToMonitor: string[]
+}
+
 // --- Agent / Delegation ---
 
 export type AgentRole = 'worker' | 'coordinator'
@@ -180,6 +191,18 @@ export interface Agent {
   orchestratorLastWakeAt?: number | null
   orchestratorCycleCount?: number
 
+  // SwarmFeed (social network integration)
+  swarmfeedEnabled?: boolean
+  swarmfeedJoinedAt?: number | null
+  swarmfeedBio?: string | null
+  swarmfeedPinnedPostId?: string | null
+  swarmfeedAutoPost?: boolean
+  swarmfeedAutoPostChannels?: string[]
+  swarmfeedApiKey?: string | null
+  swarmfeedAgentId?: string | null
+  origin?: 'swarmdock' | 'swarmfeed' | 'swarmclaw' | 'external'
+  swarmfeedHeartbeat?: SwarmFeedHeartbeatConfig | null
+
   createdAt: number
   updatedAt: number
 }
@@ -246,7 +269,7 @@ export interface AgentPackManifest {
 
 // --- External Agents ---
 
-export type ExternalAgentSourceType = 'codex' | 'claude' | 'opencode' | 'openclaw' | 'custom'
+export type ExternalAgentSourceType = 'codex' | 'claude' | 'opencode' | 'openclaw' | 'custom' | 'a2a'
 export type ExternalAgentStatus = 'online' | 'idle' | 'offline' | 'stale'
 
 export interface ExternalAgentRuntime {
@@ -274,6 +297,13 @@ export interface ExternalAgentRuntime {
     outputTokens?: number
     totalTokens?: number
   } | null
+  a2aCard?: {
+    protocolVersion?: string | null
+    apiEndpoint?: string | null
+    capabilities?: Array<{ name: string; methods?: string[]; description?: string | null }>
+    supportsStreaming?: boolean
+    supportsAsync?: boolean
+  } | null
   lastHeartbeatAt?: number | null
   lastSeenAt?: number | null
   createdAt: number

package/src/types/index.ts

@@ -16,3 +16,4 @@ export * from './misc'
 export * from './goal'
 export * from './swarmdock'
 export * from './dream'
+export * from './swarmfeed'

package/src/types/protocol.ts

@@ -16,6 +16,7 @@ export type ProtocolPhaseKind =
   | 'wait'
   | 'dispatch_task'
   | 'dispatch_delegation'
+  | 'a2a_delegate'
 
 export interface ProtocolPhaseDefinition {
   id: string
@@ -26,6 +27,15 @@ export interface ProtocolPhaseDefinition {
   completionCriteria?: string | null
   taskConfig?: { agentId?: string; title: string; description: string } | null
   delegationConfig?: { agentId: string; message: string } | null
+  a2aDelegateConfig?: {
+    targetUrl?: string | null
+    targetExternalAgentId?: string | null
+    taskName: string
+    taskMessage: string
+    timeoutMs?: number | null
+    credentialId?: string | null
+    onFailure?: 'fail' | 'advance_with_warning'
+  } | null
 }
 
 export type ProtocolConditionDefinition =
@@ -90,6 +100,15 @@ export interface ProtocolStepDefinition {
   completionCriteria?: string | null
   taskConfig?: { agentId?: string; title: string; description: string } | null
   delegationConfig?: { agentId: string; message: string } | null
+  a2aDelegateConfig?: {
+    targetUrl?: string | null
+    targetExternalAgentId?: string | null
+    taskName: string
+    taskMessage: string
+    timeoutMs?: number | null
+    credentialId?: string | null
+    onFailure?: 'fail' | 'advance_with_warning'
+  } | null
   nextStepId?: string | null
   branchCases?: ProtocolBranchCase[]
   defaultNextStepId?: string | null

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'
+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'

package/src/types/swarmfeed.ts

@@ -0,0 +1,30 @@
+export interface SwarmFeedPost {
+  id: string
+  agentId: string
+  content: string
+  channelId?: string
+  parentId?: string
+  likeCount: number
+  replyCount: number
+  repostCount: number
+  bookmarkCount: number
+  createdAt: string
+  agent?: { id: string; name: string; avatar?: string }
+}
+
+export interface SwarmFeedChannel {
+  id: string
+  handle: string
+  displayName: string
+  description?: string
+  memberCount: number
+  postCount: number
+}
+
+export interface CreatePostInput {
+  content: string
+  channelId?: string
+  parentId?: string
+}
+
+export type FeedType = 'for_you' | 'following' | 'channel' | 'trending'