@swarmclawai/swarmclaw 1.2.6 → 1.2.9

package/src/lib/server/connectors/swarmdock.ts

@@ -0,0 +1,255 @@
+import { log } from '@/lib/server/logger'
+import { hmrSingleton } from '@/lib/shared-utils'
+import { logActivity } from '@/lib/server/activity/activity-log'
+import type { Connector, InboundMessage } from '@/types/connector'
+import type { PlatformConnector, ConnectorInstance } from '@/lib/server/connectors/types'
+import { createBoardTaskFromAssignment, updateBoardTaskFromEvent, findBoardTaskBySwarmdockId } from './swarmdock-tasks'
+import { shouldAutoBid, submitAutoBid } from './swarmdock-bidding'
+import type { TaskSubmitInput } from '@swarmdock/shared'
+
+const TAG = 'swarmdock'
+
+// SDK types inlined until @swarmdock/sdk is built and linked
+interface SwarmDockTask {
+  id: string
+  requesterId: string
+  assigneeId: string | null
+  title: string
+  description: string
+  skillRequirements: string[]
+  budgetMax: string
+  status: string
+  deadline: string | null
+}
+
+interface SwarmDockSSEEvent {
+  type: string
+  data: Record<string, unknown>
+  timestamp: string
+}
+
+interface SwarmDockConfig {
+  apiUrl: string
+  walletAddress: string
+  agentDescription: string
+  skills: string
+  autoDiscover: boolean
+  maxBudget: string
+}
+
+function parseConfig(connector: Connector): SwarmDockConfig {
+  const c = connector.config || {}
+  return {
+    apiUrl: c.apiUrl || 'https://api.swarmdock.ai',
+    walletAddress: c.walletAddress || '',
+    agentDescription: c.agentDescription || connector.name || '',
+    skills: c.skills || '',
+    autoDiscover: c.autoDiscover === 'true',
+    maxBudget: c.maxBudget || '0',
+  }
+}
+
+function buildTaskPrompt(task: SwarmDockTask): string {
+  const lines: string[] = [
+    `# SwarmDock Task: ${task.title}`,
+    '',
+    task.description,
+    '',
+    `**Required Skills:** ${task.skillRequirements.join(', ')}`,
+    `**Budget:** ${formatUsdc(task.budgetMax)}`,
+  ]
+  if (task.deadline) lines.push(`**Deadline:** ${task.deadline}`)
+  lines.push('', 'Complete this task and provide your deliverables. Your response will be submitted as the task result on the SwarmDock marketplace.')
+  return lines.join('\n')
+}
+
+function formatUsdc(microUnits: string): string {
+  const cents = BigInt(microUnits)
+  const dollars = Number(cents) / 1_000_000
+  return `$${dollars.toFixed(2)} USDC`
+}
+
+export async function submitSwarmdockTaskResult(
+  client: { tasks: { submit: (taskId: string, input: TaskSubmitInput) => Promise<unknown> } },
+  swarmdockTaskId: string,
+  text: string,
+): Promise<void> {
+  const payload: TaskSubmitInput = {
+    artifacts: [{ type: 'text/markdown', content: text }],
+    files: [],
+  }
+  await client.tasks.submit(swarmdockTaskId, payload)
+}
+
+/** Runtime state: maps SwarmDock task IDs → SwarmClaw BoardTask IDs */
+const taskIdMap = hmrSingleton('__swarmclaw_swarmdock_task_map__', () => new Map<string, string>())
+
+const swarmdock: PlatformConnector = {
+  async start(connector, _botToken, onMessage): Promise<ConnectorInstance> {
+    const config = parseConfig(connector)
+    const connectorId = connector.id
+    const agentId = connector.agentId || ''
+    const privateKey = _botToken || ''
+
+    if (!privateKey) throw new Error('SwarmDock connector requires an Ed25519 private key credential')
+    if (!config.walletAddress) throw new Error('SwarmDock connector requires a Base L2 wallet address in config')
+
+    // Dynamic import of the SDK (must be built and linked first)
+    let SwarmDockClient: typeof import('@swarmdock/sdk').SwarmDockClient
+    try {
+      const sdk = await import('@swarmdock/sdk')
+      SwarmDockClient = sdk.SwarmDockClient
+    } catch {
+      throw new Error('SwarmDock SDK (@swarmdock/sdk) is not installed. Run: npm install @swarmdock/sdk')
+    }
+
+    const client = new SwarmDockClient({
+      baseUrl: config.apiUrl,
+      privateKey,
+    })
+
+    // Register agent on SwarmDock (Ed25519 challenge-response)
+    const skillList = config.skills
+      .split(',')
+      .map((s) => s.trim())
+      .filter(Boolean)
+      .map((skillId) => ({
+        skillId,
+        skillName: skillId.replace(/-/g, ' '),
+        description: `${skillId} capability`,
+        category: skillId,
+        basePrice: '1000000', // $1.00 default
+      }))
+
+    log.info(TAG, `Registering agent "${connector.name}" on SwarmDock at ${config.apiUrl}`)
+    const registration = await client.register({
+      displayName: connector.name,
+      description: config.agentDescription,
+      framework: 'swarmclaw',
+      walletAddress: config.walletAddress,
+      skills: skillList,
+    })
+    log.info(TAG, `Registered as ${registration.agent.did} (trust level ${registration.agent.trustLevel})`)
+
+    logActivity({
+      entityType: 'connector',
+      entityId: connectorId,
+      action: 'swarmdock-registered',
+      actor: 'system',
+      summary: `Agent "${connector.name}" registered on SwarmDock as ${registration.agent.did}`,
+    })
+
+    // Set up SSE event stream
+    let alive = true
+
+    const handleSSEEvent = async (event: SwarmDockSSEEvent) => {
+      if (!alive) return
+      try {
+        switch (event.type) {
+          case 'task.created': {
+            if (!config.autoDiscover) break
+            const task = event.data as unknown as SwarmDockTask
+            if (shouldAutoBid(task, config)) {
+              await submitAutoBid(client, task.id, config)
+              logActivity({
+                entityType: 'connector',
+                entityId: connectorId,
+                action: 'swarmdock-bid',
+                actor: 'system',
+                summary: `Auto-bid on SwarmDock task: "${task.title}"`,
+              })
+            }
+            break
+          }
+
+          case 'task.assigned': {
+            const task = event.data as unknown as SwarmDockTask
+            if (!task.assigneeId) break
+
+            // Signal work started on SwarmDock
+            try { await client.tasks.start(task.id) } catch {}
+
+            // Create a BoardTask in SwarmClaw
+            const boardTaskId = await createBoardTaskFromAssignment(task, agentId, connectorId, config.apiUrl)
+            taskIdMap.set(task.id, boardTaskId)
+
+            // Dispatch as inbound message to the assigned agent
+            const inbound: InboundMessage = {
+              platform: 'swarmdock',
+              channelId: `swarmdock-task:${task.id}`,
+              channelName: `SwarmDock: ${task.title}`,
+              senderId: task.requesterId,
+              senderName: `SwarmDock Requester`,
+              text: buildTaskPrompt(task),
+              messageId: task.id,
+            }
+            await onMessage(inbound)
+            break
+          }
+
+          case 'task.completed':
+          case 'task.cancelled':
+          case 'task.failed': {
+            const taskId = (event.data as Record<string, string>).taskId
+            if (taskId) await updateBoardTaskFromEvent(taskId, event.type)
+            break
+          }
+
+          case 'payment.released': {
+            const data = event.data as Record<string, string>
+            logActivity({
+              entityType: 'connector',
+              entityId: connectorId,
+              action: 'swarmdock-payment',
+              actor: 'system',
+              summary: `Payment received: ${formatUsdc(data.amount || '0')} for task ${data.taskId}`,
+            })
+            break
+          }
+        }
+      } catch (err) {
+        log.error(TAG, `Error handling SSE event ${event.type}: ${err instanceof Error ? err.message : String(err)}`)
+      }
+    }
+
+    client.events.subscribe(handleSSEEvent as (event: unknown) => void)
+
+    // Token refresh heartbeat (23h, token lasts 24h)
+    const heartbeatInterval = setInterval(async () => {
+      try {
+        await client.heartbeat()
+        log.debug(TAG, 'SwarmDock token refreshed')
+      } catch (err) {
+        log.error(TAG, `SwarmDock heartbeat failed: ${err instanceof Error ? err.message : String(err)}`)
+      }
+    }, 23 * 60 * 60 * 1000)
+
+    return {
+      connector,
+
+      stop: async () => {
+        alive = false
+        clearInterval(heartbeatInterval)
+        client.events.unsubscribe()
+        log.info(TAG, 'SwarmDock connector stopped')
+      },
+
+      sendMessage: async (channelId: string, text: string) => {
+        // channelId format: "swarmdock-task:{taskId}"
+        const swarmdockTaskId = channelId.replace('swarmdock-task:', '')
+        if (!swarmdockTaskId) return
+
+        await submitSwarmdockTaskResult(client, swarmdockTaskId, text)
+        log.info(TAG, `Submitted results for SwarmDock task ${swarmdockTaskId}`)
+
+        if (findBoardTaskBySwarmdockId(swarmdockTaskId)) {
+          await updateBoardTaskFromEvent(swarmdockTaskId, 'task.submitted')
+        }
+
+        return { messageId: swarmdockTaskId }
+      },
+    }
+  },
+}
+
+export default swarmdock

package/src/lib/server/connectors/teams.ts

@@ -1,6 +1,7 @@
 import { log } from '@/lib/server/logger'
 import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
 import { resolveConnectorIngressReply } from './ingress-delivery'
+import { errorMessage } from '@/lib/shared-utils'
 
 const TAG = 'teams'
 
@@ -51,8 +52,8 @@ const teams: PlatformConnector = {
           const reply = await resolveConnectorIngressReply(onMessage, inbound)
           if (!reply) return
           await context.sendActivity(reply.visibleText)
-        } catch (err: any) {
-          log.error(TAG, 'Error handling message:', err.message)
+        } catch (err: unknown) {
+          log.error(TAG, 'Error handling message:', errorMessage(err))
           try {
             await context.sendActivity('Sorry, I encountered an error processing your message.')
           } catch { /* ignore */ }

package/src/lib/server/connectors/telegram.ts

@@ -127,8 +127,8 @@ const telegram: PlatformConnector = {
             mimeType: m.mimeType,
           })
           if (stored) media.push(stored)
-        } catch (err: any) {
-          log.warn(TAG, `Failed to fetch media ${m.fileId}:`, err?.message || String(err))
+        } catch (err: unknown) {
+          log.warn(TAG, `Failed to fetch media ${m.fileId}:`, errorMessage(err))
           media.push({
             type: m.type,
             fileName: m.fileName,
@@ -177,8 +177,8 @@ const telegram: PlatformConnector = {
             return String(sent.message_id)
           },
         })
-      } catch (err: any) {
-        log.error(TAG, 'Error handling message:', err.message)
+      } catch (err: unknown) {
+        log.error(TAG, 'Error handling message:', errorMessage(err))
         try {
           await ctx.reply('Sorry, I encountered an error processing your message.')
         } catch { /* ignore */ }

package/src/lib/server/connectors/whatsapp.ts

@@ -714,8 +714,8 @@ const whatsapp: PlatformConnector = {
                 fileName: mediaCandidate.payload?.fileName || undefined,
               })
               media.push(saved)
-            } catch (err: any) {
-              log.error(TAG, `Failed to decode media: ${err?.message || String(err)}`)
+            } catch (err: unknown) {
+              log.error(TAG, `Failed to decode media: ${errorMessage(err)}`)
               media.push({
                 type: mediaCandidate.kind,
                 fileName: mediaCandidate.payload?.fileName || undefined,

package/src/lib/server/daemon/controller.ts

@@ -25,6 +25,7 @@ import type {
 } from '@/lib/server/daemon/types'
 import { DATA_DIR } from '@/lib/server/data-dir'
 import { loadEstopState } from '@/lib/server/runtime/estop'
+import { getDaemonStatus } from '@/lib/server/runtime/daemon-state/core'
 import { daemonAutostartEnvEnabled } from '@/lib/server/runtime/daemon-policy'
 import {
   releaseRuntimeLock,
@@ -344,6 +345,12 @@ export async function ensureDaemonProcessRunning(
   source: string,
   opts?: { manualStart?: boolean },
 ): Promise<boolean> {
+  // In dev mode, the daemon may already be running in-process (same Next.js server)
+  // without a daemon-admin.json file. Check in-process state first to avoid spawning
+  // a subprocess that fails to acquire the already-held lease.
+  const inProcessStatus = getDaemonStatus()
+  if (inProcessStatus.running) return false
+
   const manualStart = opts?.manualStart === true
   const record = loadDaemonStatusRecord()
   if (loadEstopState().level !== 'none') return false

package/src/lib/server/execution-brief.test.ts

@@ -2,7 +2,7 @@ import assert from 'node:assert/strict'
 import { test } from 'node:test'
 
 import { buildExecutionBrief, buildExecutionBriefContextBlock, serializeExecutionBriefForDelegation } from './execution-brief'
-import type { Mission, Session, SessionWorkingState } from '@/types'
+import type { Session, SessionWorkingState } from '@/types'
 
 test('buildExecutionBrief prefers working state and folds in mission and run-context fallback data', () => {
   const session = {
@@ -31,25 +31,8 @@ test('buildExecutionBrief prefers working state and folds in mission and run-con
     },
   } satisfies Partial<Session> as Session
 
-  const mission = {
-    id: 'm1',
-    source: 'chat',
-    objective: 'Ship the release fix',
-    status: 'active',
-    phase: 'executing',
-    currentStep: 'Verify staging auth',
-    successCriteria: ['Restore staging deploys'],
-    waitState: {
-      kind: 'approval',
-      reason: 'Waiting for deploy approval.',
-    },
-    createdAt: 1,
-    updatedAt: 1,
-  } satisfies Partial<Mission> as Mission
-
   const workingState = {
     sessionId: 's1',
-    missionId: 'm1',
     objective: 'Ship the release fix safely',
     summary: 'Auth mismatch isolated to staging.',
     constraints: ['Do not change the API'],
@@ -79,7 +62,7 @@ test('buildExecutionBrief prefers working state and folds in mission and run-con
     updatedAt: 1,
   } satisfies SessionWorkingState
 
-  const brief = buildExecutionBrief({ session, mission, workingState })
+  const brief = buildExecutionBrief({ session, workingState })
 
   assert.equal(brief.objective, 'Ship the release fix safely')
   assert.equal(brief.summary, 'Auth mismatch isolated to staging.')
@@ -87,11 +70,9 @@ test('buildExecutionBrief prefers working state and folds in mission and run-con
   assert.equal(brief.nextAction, 'Request deploy approval')
   assert.equal(brief.plan[0]?.text, 'Request deploy approval')
   assert.equal(brief.blockers[0], 'Deploy approval is pending. | next: Request deploy approval')
-  assert.ok(brief.blockers.some((entry) => /waiting for deploy approval/i.test(entry)))
   assert.ok(brief.facts.some((entry) => /auth mismatch isolated to staging/i.test(entry)))
   assert.ok(brief.artifacts.some((entry) => /deploy\.log/i.test(entry)))
   assert.equal(brief.parentContext, 'Parent asked for a contained fix.')
-  assert.equal(brief.missionPhase, 'executing')
 })
 
 test('buildExecutionBriefContextBlock renders a single canonical state block', () => {
@@ -139,7 +120,6 @@ test('buildExecutionBriefContextBlock renders a single canonical state block', (
 test('serializeExecutionBriefForDelegation creates a bounded handoff summary', () => {
   const text = serializeExecutionBriefForDelegation({
     sessionId: 's3',
-    missionId: 'm3',
     objective: 'Repair the deployment pipeline',
     summary: 'The regression is isolated to the release job.',
     status: 'blocked',
@@ -153,9 +133,6 @@ test('serializeExecutionBriefForDelegation creates a bounded handoff summary', (
     artifacts: ['/tmp/project/release.log'],
     constraints: ['Keep the current release shape.'],
     successCriteria: ['Production deploy completes'],
-    missionStatus: 'active',
-    missionPhase: 'executing',
-    waitState: null,
     evidenceRefs: [],
     parentContext: 'Parent is waiting on a concise status update.',
   })

package/src/lib/server/execution-brief.ts

@@ -2,7 +2,6 @@ import type {
   EvidenceRef,
   ExecutionBrief,
   ExecutionBriefPlanStep,
-  Mission,
   Session,
   SessionWorkingState,
   WorkingPlanStep,
@@ -75,14 +74,8 @@ function dedupePlan(steps: ExecutionBriefPlanStep[]): ExecutionBriefPlanStep[] {
   return out
 }
 
-function inferStatus(mission: Mission | null | undefined, workingState: SessionWorkingState | null): WorkingStateStatus {
+function inferStatus(workingState: SessionWorkingState | null): WorkingStateStatus {
   if (workingState?.status) return workingState.status
-  if (!mission) return 'idle'
-  if (mission.status === 'completed') return 'completed'
-  if (mission.status === 'waiting') return 'waiting'
-  if (mission.status === 'failed' || mission.phase === 'failed') return 'blocked'
-  if (mission.waitState) return 'waiting'
-  if (mission.phase === 'executing' || mission.phase === 'dispatching' || mission.phase === 'verifying') return 'progress'
   return 'idle'
 }
 
@@ -121,15 +114,14 @@ function buildFacts(workingState: SessionWorkingState | null, session: Session |
   return uniqueStrings([...activeFacts, ...runContextFacts], MAX_FACTS, 240)
 }
 
-function buildBlockers(workingState: SessionWorkingState | null, mission: Mission | null | undefined, session: Session | null): string[] {
+function buildBlockers(workingState: SessionWorkingState | null, session: Session | null): string[] {
   const activeBlockers = workingState
     ? workingState.blockers
       .filter((blocker) => blocker.status === 'active')
       .map((blocker) => blocker.nextAction ? `${blocker.summary} | next: ${blocker.nextAction}` : blocker.summary)
     : []
-  const missionBlockers = mission?.waitState?.reason ? [cleanText(mission.waitState.reason, 280)] : []
   const runContextBlockers = session?.runContext ? ensureRunContext(session.runContext).blockers : []
-  return uniqueStrings([...activeBlockers, ...missionBlockers, ...runContextBlockers], MAX_BLOCKERS, 280)
+  return uniqueStrings([...activeBlockers, ...runContextBlockers], MAX_BLOCKERS, 280)
 }
 
 function buildArtifacts(workingState: SessionWorkingState | null): string[] {
@@ -147,8 +139,8 @@ function buildConstraints(workingState: SessionWorkingState | null, session: Ses
   return uniqueStrings([...(workingConstraints || []), ...(runContext?.constraints || [])], 10, 220)
 }
 
-function buildSuccessCriteria(workingState: SessionWorkingState | null, mission: Mission | null | undefined): string[] {
-  return uniqueStrings([...(workingState?.successCriteria || []), ...(mission?.successCriteria || [])], 10, 220)
+function buildSuccessCriteria(workingState: SessionWorkingState | null): string[] {
+  return uniqueStrings([...(workingState?.successCriteria || [])], 10, 220)
 }
 
 function buildEvidenceRefs(workingState: SessionWorkingState | null): EvidenceRef[] {
@@ -161,49 +153,40 @@ function buildEvidenceRefs(workingState: SessionWorkingState | null): EvidenceRe
 export function buildExecutionBrief(params: {
   sessionId?: string | null
   session?: Session | null
-  mission?: Mission | null
+  mission?: null
   workingState?: SessionWorkingState | null
 }): ExecutionBrief {
   const session = params.session
     || (params.sessionId ? getSession(params.sessionId) || null : null)
-  const mission = params.mission || null
   const workingState = params.workingState
-    || (session?.id ? loadSessionWorkingState(session.id, { mission }) : null)
+    || (session?.id ? loadSessionWorkingState(session.id) : null)
   const runContext = session?.runContext ? ensureRunContext(session.runContext) : null
   const plan = buildPlan(workingState, session)
   const nextAction = cleanText(
     workingState?.nextAction
-      || mission?.currentStep
       || plan.find((step) => step.status === 'active')?.text,
     240,
   ) || null
 
   return {
     sessionId: session?.id || params.sessionId || null,
-    missionId: mission?.id || workingState?.missionId || null,
     objective: cleanMultiline(
       workingState?.objective
-        || mission?.objective
         || runContext?.objective,
       900,
     ) || null,
     summary: cleanMultiline(
-      workingState?.summary
-        || mission?.verifierSummary
-        || mission?.plannerSummary,
+      workingState?.summary,
       700,
     ) || null,
-    status: inferStatus(mission, workingState),
+    status: inferStatus(workingState),
     nextAction,
     plan,
-    blockers: buildBlockers(workingState, mission, session),
+    blockers: buildBlockers(workingState, session),
     facts: buildFacts(workingState, session),
     artifacts: buildArtifacts(workingState),
     constraints: buildConstraints(workingState, session),
-    successCriteria: buildSuccessCriteria(workingState, mission),
-    missionStatus: mission?.status || null,
-    missionPhase: mission?.phase || null,
-    waitState: mission?.waitState || null,
+    successCriteria: buildSuccessCriteria(workingState),
     evidenceRefs: buildEvidenceRefs(workingState),
     parentContext: cleanMultiline(runContext?.parentContext, 900) || null,
   }
@@ -238,10 +221,7 @@ export function buildExecutionBriefContextBlock(
     || brief.artifacts.length > 0
     || brief.constraints.length > 0
     || brief.successCriteria.length > 0
-    || brief.evidenceRefs.length > 0
-    || brief.missionStatus
-    || brief.missionPhase
-    || brief.waitState?.reason,
+    || brief.evidenceRefs.length > 0,
   )
   if (!hasContent && brief.status === 'idle') return ''
   const sections = [
@@ -250,9 +230,6 @@ export function buildExecutionBriefContextBlock(
     brief.objective ? `Objective: ${brief.objective}` : '',
     brief.summary ? `Summary: ${brief.summary}` : '',
     `Status: ${brief.status}`,
-    brief.missionStatus ? `Mission status: ${brief.missionStatus}` : '',
-    brief.missionPhase ? `Mission phase: ${brief.missionPhase}` : '',
-    brief.waitState?.reason ? `Waiting reason: ${cleanText(brief.waitState.reason, 280)}` : '',
     brief.nextAction ? `Next action: ${brief.nextAction}` : '',
     brief.successCriteria.length > 0 ? `Success criteria: ${brief.successCriteria.join(' | ')}` : '',
     brief.constraints.length > 0 ? `Constraints: ${brief.constraints.join(' | ')}` : '',

package/src/lib/server/execution-engine/task-attempt.ts

@@ -238,7 +238,6 @@ export function enqueueTaskAttemptExecution(
   const run: SessionRunRecord = {
     id: executionId,
     sessionId: input.sessionId,
-    missionId: input.task.missionId || null,
     kind: 'task_attempt',
     ownerType: 'task',
     ownerId: input.task.id,

package/src/lib/server/gateways/gateway-profile-service.ts

@@ -4,6 +4,7 @@ import { genId } from '@/lib/id'
 import { normalizeOpenClawEndpoint } from '@/lib/openclaw/openclaw-endpoint'
 import { listAgents, saveAgentMany } from '@/lib/server/agents/agent-repository'
 import { getGatewayProfiles } from '@/lib/server/agents/agent-runtime-config'
+import { deleteCredentialRecord } from '@/lib/server/credentials/credential-service'
 import {
   loadGatewayProfile,
   loadGatewayProfiles,
@@ -161,7 +162,9 @@ export function updateGatewayProfile(id: string, input: Record<string, unknown>)
 
 export function deleteGatewayProfileAndDetachAgents(id: string): boolean {
   const gateways = loadGatewayProfiles()
-  if (!gateways[id]) return false
+  const deleted = gateways[id]
+  if (!deleted) return false
+  const orphanCredentialId = deleted.credentialId || null
   delete gateways[id]
   saveGatewayProfiles(gateways)
 
@@ -195,6 +198,21 @@ export function deleteGatewayProfileAndDetachAgents(id: string): boolean {
   }
 
   if (changed.length > 0) saveAgentMany(changed)
+
+  // Clean up orphaned credential if no other gateway or agent references it
+  if (orphanCredentialId) {
+    const stillReferencedByGateway = Object.values(gateways).some(
+      (gw) => gw && gw.credentialId === orphanCredentialId,
+    )
+    const stillReferencedByAgent = !stillReferencedByGateway && Object.values(agents).some(
+      (a) => a.credentialId === orphanCredentialId
+        || (Array.isArray(a.fallbackCredentialIds) && a.fallbackCredentialIds.includes(orphanCredentialId)),
+    )
+    if (!stillReferencedByGateway && !stillReferencedByAgent) {
+      deleteCredentialRecord(orphanCredentialId)
+    }
+  }
+
   notify('gateways')
   return true
 }

package/src/lib/server/messages/message-repository.test.ts

@@ -0,0 +1,70 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
+
+test('appendMessage notifies both generic and per-session message topics', () => {
+  const output = runWithTempDataDir<{
+    genericTopics: string[]
+    sessionTopics: string[]
+  }>(`
+    const { WebSocket } = await import('ws')
+    const storageMod = await import('@/lib/server/storage')
+    const repoMod = await import('@/lib/server/messages/message-repository')
+    const storage = storageMod.default || storageMod
+    const repo = repoMod.default || repoMod
+
+    storage.saveSessions({
+      'sess-notify': {
+        id: 'sess-notify',
+        name: 'Notify Session',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'tester',
+        provider: 'openai',
+        model: 'gpt-5',
+        claudeSessionId: null,
+        codexThreadId: null,
+        opencodeSessionId: null,
+        delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null },
+        messages: [],
+        createdAt: Date.now(),
+        lastActiveAt: Date.now(),
+      },
+    })
+
+    const genericPayloads = []
+    const sessionPayloads = []
+    globalThis.__swarmclaw_ws__ = {
+      wss: null,
+      clients: new Set([
+        {
+          ws: {
+            readyState: WebSocket.OPEN,
+            send(payload) { genericPayloads.push(JSON.parse(payload)) },
+          },
+          topics: new Set(['messages']),
+        },
+        {
+          ws: {
+            readyState: WebSocket.OPEN,
+            send(payload) { sessionPayloads.push(JSON.parse(payload)) },
+          },
+          topics: new Set(['messages:sess-notify']),
+        },
+      ]),
+    }
+
+    repo.appendMessage('sess-notify', {
+      role: 'user',
+      text: 'hello',
+      time: 1,
+    })
+
+    console.log(JSON.stringify({
+      genericTopics: genericPayloads.map((payload) => payload.topic),
+      sessionTopics: sessionPayloads.map((payload) => payload.topic),
+    }))
+  `, { prefix: 'swarmclaw-message-repo-notify-' })
+
+  assert.deepEqual(output.genericTopics, ['messages'])
+  assert.deepEqual(output.sessionTopics, ['messages:sess-notify'])
+})